DO NOT MERGE: pessimize solx-evm-assembly block map to test the summary

Replaces the per-function block BTreeMap with a flat Vec kept sorted by key, so
lookups (get_mut during traversal) and find-or-insert degrade from O(log n) to
linear scans, i.e. O(n^2) block construction. This is a realistic algorithmic
compile-time regression, not a synthetic sleep, for validating the integration
benchmark summary against real data.

Order is preserved (the Vec stays sorted), so emission order and generated
bytecode are unchanged; only compile time regresses. Bounded by the EVM
24 KB code-size limit on per-function block counts, so it stays well inside the
300-minute job timeout. Revert before merging.

Author: hedgar2017

solx-evm-assembly/src/ethereal_ir/function/mod.rs

@@ -52,7 +52,12 @@ pub struct Function {
     /// The optional code segment. Only used for the EVM target.
     pub code_segment: solx_utils::CodeSegment,
     /// The separately labelled blocks.
-    pub blocks: BTreeMap<solx_codegen_evm::BlockKey, Vec<Block>>,
+    ///
+    /// DUMMY BENCHMARK PROBE, DO NOT MERGE. This was a `BTreeMap` keyed by
+    /// block; it is now a flat vector kept sorted by key so lookups degrade to
+    /// linear scans, giving the PR toolchain a real compile-time regression for
+    /// the integration summary to report. Restore the `BTreeMap` before merging.
+    pub blocks: Vec<(solx_codegen_evm::BlockKey, Vec<Block>)>,
     /// The function type.
     pub r#type: Type,
     /// The function stack size.
@@ -84,7 +89,7 @@ impl Function {
             solc_version,
             name,
             code_segment,
-            blocks: BTreeMap::new(),
+            blocks: Vec::new(),
             r#type,
             stack_size: 0,
             capture_stacks,
@@ -169,8 +174,9 @@ impl Function {
         if let Some(&instance) = visited_blocks.get(&visited_element) {
             if let Some(predecessor) = queue_element.predecessor.take() {
                 self.blocks
-                    .get_mut(&queue_element.block_key)
-                    .and_then(|instances| instances.get_mut(instance))
+                    .iter_mut()
+                    .find(|(key, _)| key == &queue_element.block_key)
+                    .and_then(|(_, instances)| instances.get_mut(instance))
                     .expect("Always exists")
                     .insert_predecessor(predecessor.0, predecessor.1);
             }
@@ -1387,7 +1393,20 @@ impl Function {
     /// Pushes a block into the function.
     ///
     fn insert_block(&mut self, mut block: Block) -> &mut Block {
-        let instances = self.blocks.entry(block.key.clone()).or_default();
+        let index = match self.blocks.iter().position(|(key, _)| key == &block.key) {
+            Some(index) => index,
+            None => {
+                let insert_at = self
+                    .blocks
+                    .iter()
+                    .position(|(key, _)| key > &block.key)
+                    .unwrap_or(self.blocks.len());
+                self.blocks
+                    .insert(insert_at, (block.key.clone(), Vec::new()));
+                insert_at
+            }
+        };
+        let instances = &mut self.blocks[index].1;
         block.instance = Some(instances.len());
         instances.push(block);
         instances.last_mut().expect("Always exists")