LibJS: Outline slow-path-only AsmInt handlers

Add a handler-level @Cold annotation restricted to handlers whose
entire implementation is one call_slow_path operation. Emit their
dispatch entry symbols in the shared cold region on both native
backends.

Mark all 95 matching handlers cold. This reduces the contiguous x86-64
hot handler span from about 24 KiB to about 18 KiB.

Author: awesomekling

Libraries/LibJS/AsmIntGen/src/codegen_aarch64.rs

@@ -499,11 +499,6 @@ fn generate_handler(
     program: &Program,
     pinned: &PinnedConstants,
 ) -> String {
-    emit_handler_alignment(out, program.object_format);
-    w!(out, "asm_handler_{}:", handler.name);
-    // x21 = pb + pc is set by the dispatch sequence that branches here.
-    // It is callee-saved, so it survives C++ calls within the handler.
-
     let mut state = HandlerState::new();
 
     let mut counter = state.unique_counter;
@@ -516,6 +511,26 @@ fn generate_handler(
         });
     state.unique_counter = counter;
 
+    if handler.is_cold {
+        assert!(
+            matches!(instructions.as_slice(), [instruction] if instruction.mnemonic == "call_slow_path"),
+            "cold handler '{}' must consist solely of call_slow_path",
+            handler.name
+        );
+        let mut cold = String::new();
+        emit_handler_alignment(&mut cold, program.object_format);
+        w!(cold, "asm_handler_{}:", handler.name);
+        emit_instruction(&mut cold, &instructions[0], handler, program, &mut state, pinned);
+        cold.push_str(&state.cold_blocks);
+        w!(cold);
+        return cold;
+    }
+
+    emit_handler_alignment(out, program.object_format);
+    w!(out, "asm_handler_{}:", handler.name);
+    // x21 = pb + pc is set by the dispatch sequence that branches here.
+    // It is callee-saved, so it survives C++ calls within the handler.
+
     let (hot_instructions, cold_instructions) = outline_cold_blocks(&instructions)
         .unwrap_or_else(|error| panic!("invalid cold block in handler '{}': {error}", handler.name));
 
@@ -2978,6 +2993,7 @@ mod tests {
             handlers: vec![Handler {
                 name: "Call".into(),
                 size: Some(1),
+                is_cold: false,
                 instructions,
             }],
             op_layouts: HashMap::from([(
@@ -3027,4 +3043,17 @@ mod tests {
         assert!(output.contains("    ldr x1, [sp, #120]"));
         assert!(output.contains("    ldr x0, [sp, #112]"));
     }
+
+    #[test]
+    fn emits_cold_handler_after_hot_region() {
+        let mut program = coff_program(vec![AsmInstruction {
+            mnemonic: "call_slow_path".into(),
+            operands: vec![Operand::Register("slow_path".into())],
+        }]);
+        program.handlers[0].is_cold = true;
+
+        let output = generate(&program);
+
+        assert!(output.find("asm_cold_handler_paths:").unwrap() < output.find("asm_handler_Call:").unwrap());
+    }
 }

Libraries/LibJS/AsmIntGen/src/codegen_x86_64.rs

@@ -435,9 +435,6 @@ fn handler_size(handler: &Handler, program: &Program) -> u32 {
 }
 
 fn generate_handler(out: &mut String, handler: &Handler, program: &Program, abi: X86_64Abi) -> String {
-    w!(out, ".p2align 4");
-    w!(out, "asm_handler_{}:", handler.name);
-
     let mut state = HandlerState::new();
 
     let mut counter = state.unique_counter;
@@ -450,6 +447,24 @@ fn generate_handler(out: &mut String, handler: &Handler, program: &Program, abi:
         });
     state.unique_counter = counter;
 
+    if handler.is_cold {
+        assert!(
+            matches!(instructions.as_slice(), [instruction] if instruction.mnemonic == "call_slow_path"),
+            "cold handler '{}' must consist solely of call_slow_path",
+            handler.name
+        );
+        let mut cold = String::new();
+        w!(cold, ".p2align 4");
+        w!(cold, "asm_handler_{}:", handler.name);
+        emit_instruction(&mut cold, &instructions[0], handler, program, &mut state, abi);
+        cold.push_str(&state.cold_blocks);
+        w!(cold);
+        return cold;
+    }
+
+    w!(out, ".p2align 4");
+    w!(out, "asm_handler_{}:", handler.name);
+
     let (hot_instructions, cold_instructions) = outline_cold_blocks(&instructions)
         .unwrap_or_else(|error| panic!("invalid cold block in handler '{}': {error}", handler.name));
 
@@ -1831,6 +1846,7 @@ mod tests {
         Handler {
             name: "Call".into(),
             size: None,
+            is_cold: false,
             instructions: Vec::new(),
         }
     }

Libraries/LibJS/AsmIntGen/src/parser.rs

@@ -38,6 +38,7 @@ pub struct AsmInstruction {
 pub struct Handler {
     pub name: String,
     pub size: Option<u32>,
+    pub is_cold: bool,
     pub instructions: Vec<AsmInstruction>,
 }
 
@@ -116,8 +117,8 @@ pub fn parse(input: &str) -> Program {
             macros.insert(name, Macro { params, body });
             i += 1;
         } else if let Some(rest) = line.strip_prefix("handler ") {
-            // handler Name, size=N
-            let (name, size) = parse_handler_header(rest);
+            // handler Name [@cold], size=N
+            let (name, size, is_cold) = parse_handler_header(rest);
             i += 1;
             let mut instructions = Vec::new();
             while i < lines.len() {
@@ -133,6 +134,7 @@ pub fn parse(input: &str) -> Program {
             handlers.push(Handler {
                 name,
                 size,
+                is_cold,
                 instructions,
             });
             i += 1;
@@ -185,17 +187,20 @@ fn parse_macro_signature(s: &str) -> (String, Vec<String>) {
     }
 }
 
-fn parse_handler_header(s: &str) -> (String, Option<u32>) {
+fn parse_handler_header(s: &str) -> (String, Option<u32>, bool) {
     let parts: Vec<&str> = s.split(',').collect();
-    let name = parts[0].trim().to_string();
+    let header = parts[0].trim();
+    let (name, is_cold) = header
+        .strip_suffix(" @cold")
+        .map_or((header, false), |name| (name, true));
     let mut size = None;
     for part in &parts[1..] {
         let part = part.trim();
         if let Some(val) = part.strip_prefix("size=") {
             size = Some(val.trim().parse().unwrap());
         }
     }
-    (name, size)
+    (name.to_string(), size, is_cold)
 }
 
 fn parse_asm_instructions(line: &str) -> Vec<AsmInstruction> {
@@ -377,4 +382,13 @@ mod tests {
         assert_eq!(instructions[1].mnemonic, "label");
         assert!(matches!(instructions[1].operands.as_slice(), [Operand::Label(label)] if label == ".slow"));
     }
+
+    #[test]
+    fn parses_cold_handler_annotation() {
+        let program = parse("handler Throw @cold\n    call_slow_path slow\nend\n");
+        let handler = &program.handlers[0];
+
+        assert_eq!(handler.name, "Throw");
+        assert!(handler.is_cold);
+    }
 }

Libraries/LibJS/AsmIntGen/src/shared.rs

@@ -457,6 +457,7 @@ mod tests {
         Handler {
             name: "Call".into(),
             size: None,
+            is_cold: false,
             instructions: Vec::new(),
         }
     }