Vec micro-opts

Summary

  4 files modified with Vec::with_capacity() optimizations:

  | File                                | Change                        | Capacity                                   |
  |-------------------------------------|-------------------------------|--------------------------------------------|
  | awk/interpreter/mod.rs:64           | gather_values                 | count as usize                             |
  | awk/interpreter/mod.rs:76           | print_to_string               | argc as usize                              |
  | text/cut.rs:129                     | cut_bytes                     | line.len()                                 |
  | cc/arch/x86_64/codegen.rs:1901      | stack_arg_indices             | insn.src.len()                             |
  | cc/ir/linearize.rs:841-845          | struct_params, complex_params | func.params.len()                          |
  | cc/arch/x86_64/codegen.rs:3737-3753 | 7 inline asm arrays           | operand_count, outputs.len(), inputs.len() |

Author: jgarzik

awk/interpreter/mod.rs

@@ -61,7 +61,7 @@ fn strtod(s: &str) -> f64 {
 }
 
 fn gather_values(stack: &mut Stack, count: u16) -> Result<Vec<AwkValue>, String> {
-    let mut values = Vec::new();
+    let mut values = Vec::with_capacity(count as usize);
     for _ in 0..count {
         values.push(stack.pop_scalar_value()?);
     }
@@ -73,7 +73,7 @@ fn print_to_string(
     argc: u16,
     global_env: &GlobalEnv,
 ) -> Result<AwkString, String> {
-    let mut values = Vec::new();
+    let mut values = Vec::with_capacity(argc as usize);
     for _ in 0..argc {
         values.push(
             stack

cc/arch/x86_64/codegen.rs

@@ -1898,7 +1898,7 @@ impl X86_64CodeGen {
         // First pass: determine which args go on stack
         // For variadic calls: variadic INTEGER args go on stack, variadic FLOAT args use XMM
         // For non-variadic calls: overflow args go on stack
-        let mut stack_arg_indices = Vec::new();
+        let mut stack_arg_indices = Vec::with_capacity(insn.src.len());
         let mut temp_int_idx = 0;
         let mut temp_fp_idx = 0;
 
@@ -3734,22 +3734,23 @@ impl X86_64CodeGen {
         // Build operand strings for asm substitution
         // For constraints requiring specific registers (a,b,c,d,S,D), we use those registers
         // and emit mov instructions to/from the actual locations.
-        let mut operand_regs: Vec<Option<Reg>> = Vec::new();
-        let mut operand_mem: Vec<Option<String>> = Vec::new();
-        let mut operand_names: Vec<Option<String>> = Vec::new();
+        let operand_count = asm_data.outputs.len() + asm_data.inputs.len();
+        let mut operand_regs: Vec<Option<Reg>> = Vec::with_capacity(operand_count);
+        let mut operand_mem: Vec<Option<String>> = Vec::with_capacity(operand_count);
+        let mut operand_names: Vec<Option<String>> = Vec::with_capacity(operand_count);
 
         // Track which outputs need to be moved from specific registers after asm
         // (output_idx, specific_reg, actual_loc)
-        let mut output_moves: Vec<(usize, Reg, Loc)> = Vec::new();
+        let mut output_moves: Vec<(usize, Reg, Loc)> = Vec::with_capacity(asm_data.outputs.len());
 
         // Track which inputs need to be moved to specific registers before asm
         // (specific_reg, actual_loc)
-        let mut input_moves: Vec<(Reg, Loc)> = Vec::new();
+        let mut input_moves: Vec<(Reg, Loc)> = Vec::with_capacity(asm_data.inputs.len());
 
         // Track register remaps: if an allocated reg conflicts with reserved, use temp
         // (original_reg, temp_reg, actual_loc for restore)
-        let mut remap_setup: Vec<(Reg, Reg, Loc)> = Vec::new();
-        let mut remap_restore: Vec<(Reg, Reg, Loc)> = Vec::new();
+        let mut remap_setup: Vec<(Reg, Reg, Loc)> = Vec::with_capacity(operand_count);
+        let mut remap_restore: Vec<(Reg, Reg, Loc)> = Vec::with_capacity(operand_count);
 
         // Track which pseudos have been assigned temp registers (for +r where input/output share pseudo)
         let mut pseudo_to_temp: std::collections::HashMap<PseudoId, Reg> =

cc/ir/linearize.rs

@@ -838,9 +838,11 @@ impl<'a> Linearizer<'a> {
         // Add parameters
         // For struct/union parameters, we need to copy them to local storage
         // so member access works properly
-        let mut struct_params: Vec<(String, TypeId, PseudoId)> = Vec::new();
+        let mut struct_params: Vec<(String, TypeId, PseudoId)> =
+            Vec::with_capacity(func.params.len());
         // Complex parameters also need local storage for real/imag access
-        let mut complex_params: Vec<(String, TypeId, PseudoId)> = Vec::new();
+        let mut complex_params: Vec<(String, TypeId, PseudoId)> =
+            Vec::with_capacity(func.params.len());
 
         for (i, param) in func.params.iter().enumerate() {
             let name = param

text/cut.rs

@@ -126,7 +126,7 @@ fn is_character_boundary(bytes: &[u8]) -> bool {
 /// A vector containing the selected bytes from the input line based on the specified ranges.
 ///
 fn cut_bytes(line: &[u8], delim: Option<char>, ranges: &Vec<(i32, i32)>, n: bool) -> Vec<u8> {
-    let mut result = Vec::new();
+    let mut result = Vec::with_capacity(line.len());
 
     for (start, end) in ranges {
         let mut start = *start as usize;