Revert "Add configurables section offset in the preamble (#6522)"

This reverts commit 0555973.

forc-pkg/src/pkg.rs

@@ -46,7 +46,7 @@ use sway_core::{
     transform::AttributeKind,
     write_dwarf, BuildTarget, Engines, FinalizedEntry, LspConfig,
 };
-use sway_core::{set_bytecode_configurables_offset, PrintAsm, PrintIr};
+use sway_core::{PrintAsm, PrintIr};
 use sway_error::{error::CompileError, handler::Handler, warning::CompileWarning};
 use sway_features::ExperimentalFeatures;
 use sway_types::constants::{CORE, PRELUDE, STD};
@@ -1914,7 +1914,7 @@ pub fn compile(
 
     let errored = handler.has_errors() || (handler.has_warnings() && profile.error_on_warnings);
 
-    let mut compiled = match bc_res {
+    let compiled = match bc_res {
         Ok(compiled) if !errored => compiled,
         _ => return fail(handler),
     };
@@ -1923,12 +1923,9 @@ pub fn compile(
 
     print_warnings(engines.se(), terse_mode, &pkg.name, &warnings, &tree_type);
 
-    // Metadata to be placed into the binary.
-    let mut md = [0u8, 0, 0, 0, 0, 0, 0, 0];
     // TODO: This should probably be in `fuel_abi_json::generate_json_abi_program`?
     // If ABI requires knowing config offsets, they should be inputs to ABI gen.
     if let ProgramABI::Fuel(ref mut program_abi) = program_abi {
-        let mut configurables_offset = compiled.bytecode.len() as u64;
         if let Some(ref mut configurables) = program_abi.configurables {
             // Filter out all dead configurables (i.e. ones without offsets in the bytecode)
             configurables.retain(|c| {
@@ -1937,22 +1934,12 @@ pub fn compile(
                     .contains_key(&c.name)
             });
             // Set the actual offsets in the JSON object
-            for (config, offset) in &compiled.named_data_section_entries_offsets {
-                if *offset < configurables_offset {
-                    configurables_offset = *offset;
-                }
-                if let Some(idx) = configurables.iter().position(|c| &c.name == config) {
-                    configurables[idx].offset = *offset;
+            for (config, offset) in compiled.named_data_section_entries_offsets {
+                if let Some(idx) = configurables.iter().position(|c| c.name == config) {
+                    configurables[idx].offset = offset;
                 }
             }
         }
-
-        md = configurables_offset.to_be_bytes();
-    }
-
-    // We know to set the metadata only for fuelvm right now.
-    if let BuildTarget::Fuel = pkg.target {
-        set_bytecode_configurables_offset(&mut compiled, &md);
     }
 
     metrics.bytecode_size = compiled.bytecode.len();

forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json

@@ -251,62 +251,62 @@
     {
       "name": "BOOL",
       "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
-      "offset": 240
+      "offset": 136
     },
     {
       "name": "U8",
       "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
-      "offset": 352
+      "offset": 248
     },
     {
       "name": "U16",
       "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
-      "offset": 296
+      "offset": 192
     },
     {
       "name": "U32",
       "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
-      "offset": 336
+      "offset": 232
     },
     {
       "name": "U64",
       "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
-      "offset": 344
+      "offset": 240
     },
     {
       "name": "U256",
       "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
-      "offset": 304
+      "offset": 200
     },
     {
       "name": "B256",
       "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
-      "offset": 208
+      "offset": 104
     },
     {
       "name": "STR_4",
       "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
-      "offset": 280
+      "offset": 176
     },
     {
       "name": "TUPLE",
       "concreteTypeId": "e0128f7be9902d1fe16326cafe703b52038064a7997b03ebfc1c9dd607e1536c",
-      "offset": 288
+      "offset": 184
     },
     {
       "name": "ARRAY",
       "concreteTypeId": "d9fac01ab38fe10950758ae9604da330d6406a71fda3ef1ea818121261132d56",
-      "offset": 192
+      "offset": 88
     },
     {
       "name": "STRUCT",
       "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
-      "offset": 264
+      "offset": 160
     },
     {
       "name": "ENUM",
       "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
-      "offset": 248
+      "offset": 144
     }
   ]
 }

forc-test/src/execute.rs

@@ -9,7 +9,7 @@ use fuel_vm::{
     self as vm,
     checked_transaction::builder::TransactionBuilderExt,
     interpreter::{Interpreter, NotSupportedEcal},
-    prelude::SecretKey,
+    prelude::{Instruction, SecretKey},
     storage::MemoryStorage,
 };
 use rand::{Rng, SeedableRng};
@@ -246,21 +246,18 @@ impl TestExecutor {
 /// The following is how the beginning of the bytecode is laid out:
 ///
 /// ```ignore
-/// [ 0] ji   i(4 + 2)                 ; Jumps to the data section setup.
-/// [ 1] noop
-/// [ 2] DATA_SECTION_OFFSET[0..32]
-/// [ 3] DATA_SECTION_OFFSET[32..64]
-/// [ 4] CONFIGURABLES_OFFSET[0..32]
-/// [ 5] CONFIGURABLES_OFFSET[32..64]
-/// [ 6] lw   $ds $is 1                ; The data section setup, i.e. where the first ji lands.
-/// [ 7] add  $$ds $$ds $is
-/// [ 8] <first-entry-point>           ; This is where we want to jump from to our test code!
+/// [0] ji   i4                       ; Jumps to the data section setup.
+/// [1] noop
+/// [2] DATA_SECTION_OFFSET[0..32]
+/// [3] DATA_SECTION_OFFSET[32..64]
+/// [4] lw   $ds $is 1                ; The data section setup, i.e. where the first ji lands.
+/// [5] add  $$ds $$ds $is
+/// [6] <first-entry-point>           ; This is where we want to jump from to our test code!
 /// ```
 fn patch_test_bytecode(bytecode: &[u8], test_offset: u32) -> std::borrow::Cow<[u8]> {
-    // Each instruction is 4 bytes,
-    // so we divide the total byte-size by 4 to get the instruction offset.
-    const PROGRAM_START_INST_OFFSET: u32 = (sway_core::PRELUDE_SIZE_IN_BYTES / 4) as u32;
-    const PROGRAM_START_BYTE_OFFSET: usize = sway_core::PRELUDE_SIZE_IN_BYTES;
+    // TODO: Standardize this or add metadata to bytecode.
+    const PROGRAM_START_INST_OFFSET: u32 = 6;
+    const PROGRAM_START_BYTE_OFFSET: usize = PROGRAM_START_INST_OFFSET as usize * Instruction::SIZE;
 
     // If our desired entry point is the program start, no need to jump.
     if test_offset == PROGRAM_START_INST_OFFSET {

forc/src/cli/commands/parse_bytecode.rs

@@ -59,14 +59,6 @@ pub(crate) fn exec(command: Command) -> ForcResult<()> {
                     parsed_raw
                 )
             }
-            Err(fuel_asm::InvalidOpcode) if word_ix == 4 || word_ix == 5 => {
-                let parsed_raw = u32::from_be_bytes([raw[0], raw[1], raw[2], raw[3]]);
-                format!(
-                    "configurables offset {} ({})",
-                    if word_ix == 4 { "lo" } else { "hi" },
-                    parsed_raw
-                )
-            }
             Ok(_) | Err(fuel_asm::InvalidOpcode) => "".into(),
         };
         table.add_row(Row::new(vec![

forc/tests/cli_integration.rs

@@ -49,10 +49,10 @@ fn test_forc_test_raw_logs() -> Result<(), rexpect::error::Error> {
     // Assert that the output is correct
     process.exp_string("      test test_log_4")?;
     process.exp_string("Raw logs:")?;
-    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12672,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12664,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
     process.exp_string("      test test_log_2")?;
     process.exp_string("Raw logs:")?;
-    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12672,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12664,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
 
     process.process.exit()?;
     Ok(())
@@ -74,11 +74,11 @@ fn test_forc_test_both_logs() -> Result<(), rexpect::error::Error> {
     process.exp_string("      test test_log_4")?;
     process.exp_string("Decoded log value: 4, log rb: 1515152261580153489")?;
     process.exp_string("Raw logs:")?;
-    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12672,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12664,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
     process.exp_string("      test test_log_2")?;
     process.exp_string("Decoded log value: 2, log rb: 1515152261580153489")?;
     process.exp_string("Raw logs:")?;
-    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12672,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12664,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
     process.process.exit()?;
     Ok(())
 }

sway-core/src/asm_generation/finalized_asm.rs

@@ -3,8 +3,8 @@ use super::{
     fuel::{checks, data_section::DataSection},
     ProgramABI, ProgramKind,
 };
-use crate::asm_generation::fuel::data_section::{Datum, Entry, EntryName};
-use crate::asm_lang::allocated_ops::{AllocatedOp, AllocatedOpcode, FuelAsmData};
+use crate::asm_generation::fuel::data_section::{DataId, Datum, Entry};
+use crate::asm_lang::allocated_ops::{AllocatedOp, AllocatedOpcode};
 use crate::decl_engine::DeclRefFunction;
 use crate::source_map::SourceMap;
 use crate::BuildConfig;
@@ -16,6 +16,7 @@ use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::span::Span;
 use sway_types::SourceEngine;
 
+use either::Either;
 use std::{collections::BTreeMap, fmt};
 
 /// Represents an ASM set which has had register allocation, jump elimination, and optimization
@@ -111,7 +112,6 @@ fn to_bytecode_mut(
             {
                 8
             }
-            AllocatedOpcode::ConfigurablesOffsetPlaceholder => 8,
             AllocatedOpcode::DataSectionOffsetPlaceholder => 8,
             AllocatedOpcode::BLOB(count) => count.value as u64 * 4,
             AllocatedOpcode::CFEI(i) | AllocatedOpcode::CFSI(i) if i.value == 0 => 0,
@@ -141,29 +141,6 @@ fn to_bytecode_mut(
         &ops_padded
     };
 
-    let mut offset_from_instr_start = 0;
-    for op in ops.iter() {
-        match &op.opcode {
-            AllocatedOpcode::LoadDataId(_reg, data_label)
-                if !data_section
-                    .has_copy_type(data_label)
-                    .expect("data label references non existent data -- internal error") =>
-            {
-                // For non-copy type loads, pre-insert pointers into the data_section so that
-                // from this point on, the data_section remains immutable. This is necessary
-                // so that when we take addresses of configurables, that address doesn't change
-                // later on if a non-configurable is added to the data-section.
-                let offset_bytes = data_section.data_id_to_offset(data_label) as u64;
-                // The -4 is because $pc is added in the *next* instruction.
-                let pointer_offset_from_current_instr =
-                    offset_to_data_section_in_bytes - offset_from_instr_start + offset_bytes - 4;
-                data_section.append_pointer(pointer_offset_from_current_instr);
-            }
-            _ => (),
-        }
-        offset_from_instr_start += op_size_in_bytes(data_section, op);
-    }
-
     let mut bytecode = Vec::with_capacity(offset_to_data_section_in_bytes as usize);
 
     if build_config.print_bytecode {
@@ -189,7 +166,7 @@ fn to_bytecode_mut(
         offset_from_instr_start += op_size_in_bytes(data_section, op);
 
         match fuel_op {
-            FuelAsmData::DatasectionOffset(data) => {
+            Either::Right(data) => {
                 if build_config.print_bytecode {
                     print!("{}{:#010x} ", " ".repeat(indentation), bytecode.len());
                     println!(
@@ -205,23 +182,7 @@ fn to_bytecode_mut(
                 bytecode.extend(data.iter().cloned());
                 half_word_ix += 2;
             }
-            FuelAsmData::ConfigurablesOffset(data) => {
-                if build_config.print_bytecode {
-                    print!("{}{:#010x} ", " ".repeat(indentation), bytecode.len());
-                    println!(
-                        "                                                ;; {:?}",
-                        data
-                    );
-                }
-
-                // Static assert to ensure that we're only dealing with ConfigurablesOffsetPlaceholder,
-                // a 1-word (8 bytes) data within the code. No other uses are known.
-                let _: [u8; 8] = data;
-
-                bytecode.extend(data.iter().cloned());
-                half_word_ix += 2;
-            }
-            FuelAsmData::Instructions(instructions) => {
+            Either::Left(instructions) => {
                 for instruction in instructions {
                     // Print original source span only once
                     if build_config.print_bytecode_spans {
@@ -334,9 +295,9 @@ fn to_bytecode_mut(
             };
         }
 
-        for (i, entry) in data_section.iter_all_entries().enumerate() {
-            let entry_offset = data_section.absolute_idx_to_offset(i);
-            print_entry(indentation, offset + entry_offset, &entry);
+        for (i, entry) in data_section.value_pairs.iter().enumerate() {
+            let entry_offset = data_section.data_id_to_offset(&DataId(i as u32));
+            print_entry(indentation, offset + entry_offset, entry);
         }
 
         println!(";; --- END OF TARGET BYTECODE ---\n");
@@ -345,19 +306,16 @@ fn to_bytecode_mut(
     assert_eq!(half_word_ix * 4, offset_to_data_section_in_bytes as usize);
     assert_eq!(bytecode.len(), offset_to_data_section_in_bytes as usize);
 
-    let num_nonconfigurables = data_section.non_configurables.len();
     let named_data_section_entries_offsets = data_section
-        .configurables
+        .value_pairs
         .iter()
         .enumerate()
+        .filter(|entry| entry.1.name.is_some())
         .map(|(id, entry)| {
-            let EntryName::Configurable(name) = &entry.name else {
-                panic!("Non-configurable in configurables part of datasection");
-            };
             (
-                name.clone(),
+                entry.name.as_ref().unwrap().clone(),
                 offset_to_data_section_in_bytes
-                    + data_section.absolute_idx_to_offset(id + num_nonconfigurables) as u64,
+                    + data_section.raw_data_id_to_offset(id as u32) as u64,
             )
         })
         .collect::<BTreeMap<String, u64>>();

sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs

@@ -1,10 +1,7 @@
-use crate::{
-    asm_generation::fuel::data_section::EntryName,
-    asm_lang::{
-        allocated_ops::{AllocatedOpcode, AllocatedRegister},
-        AllocatedAbstractOp, ConstantRegister, ControlFlowOp, Label, RealizedOp,
-        VirtualImmediate12, VirtualImmediate18, VirtualImmediate24,
-    },
+use crate::asm_lang::{
+    allocated_ops::{AllocatedOpcode, AllocatedRegister},
+    AllocatedAbstractOp, ConstantRegister, ControlFlowOp, Label, RealizedOp, VirtualImmediate12,
+    VirtualImmediate18, VirtualImmediate24,
 };
 
 use super::{
@@ -351,13 +348,6 @@ impl AllocatedAbstractInstructionSet {
                             comment: String::new(),
                         });
                     }
-                    ControlFlowOp::ConfigurablesOffsetPlaceholder => {
-                        realized_ops.push(RealizedOp {
-                            opcode: AllocatedOpcode::ConfigurablesOffsetPlaceholder,
-                            owning_span: None,
-                            comment: String::new(),
-                        });
-                    }
                     ControlFlowOp::LoadLabel(r1, ref lab) => {
                         // LoadLabel ops are inserted by `rewrite_far_jumps`.
                         // So the next instruction must be a relative jump.
@@ -373,11 +363,8 @@ impl AllocatedAbstractInstructionSet {
                         // We compute the relative offset w.r.t the actual jump.
                         // Sub 1 because the relative jumps add a 1.
                         let offset = rel_offset(curr_offset + 1, lab) - 1;
-                        let data_id = data_section.insert_data_value(Entry::new_word(
-                            offset,
-                            EntryName::NonConfigurable,
-                            None,
-                        ));
+                        let data_id =
+                            data_section.insert_data_value(Entry::new_word(offset, None, None));
                         realized_ops.push(RealizedOp {
                             opcode: AllocatedOpcode::LoadDataId(r1, data_id),
                             owning_span,
@@ -486,8 +473,6 @@ impl AllocatedAbstractInstructionSet {
                 2
             }
 
-            Either::Right(ConfigurablesOffsetPlaceholder) => 2,
-
             Either::Right(PushAll(_)) | Either::Right(PopAll(_)) => unreachable!(
                 "fix me, pushall and popall don't really belong in control flow ops \
                         since they're not about control flow"