perf(compile): reduce generated bundle bloat

changelog.d/8418-generated-bundle-size.md

@@ -0,0 +1,13 @@
+### Improved
+
+- Reduced native output for large dependency graphs by removing obsolete
+  program-wide class metadata augmentation and by keeping imported JSON
+  serialized until `JSON.parse` runs at startup. On the 4,743-module OpenCode
+  source build this cut the Windows executable from 1,685.4 MiB to 1,143.7 MiB
+  and reduced module-codegen time by 12.8%.
+- Added opt-in hybrid size optimization with
+  `PERRY_LL_PREOPT_OPTNONE_INSTRS`: generated functions above the configured
+  instruction cap skip the LLVM middle-end while ordinary siblings in the same
+  codegen unit remain eligible for `-Os`. With an 8,192-instruction cap, the
+  same OpenCode executable shrank further to 797.0 MiB (52.7% below baseline);
+  module codegen took 88.8 minutes versus the 73.2-minute baseline.

crates/perry-codegen/src/inprocess.rs

@@ -8,7 +8,7 @@
 //!
 //! Decision parity by construction: this module does not re-derive optimization
 //! or CPU tuning. It interprets the *same* argv `build_clang_compile_plan`
-//! produces for clang (`-O3`, `-mcpu=native`, `-mllvm
+//! produces for clang (`-O3`/explicit `-Os`, `-mcpu=native`, `-mllvm
 //! -inlinehint-threshold=N`, `-target <triple>`), so the two backends cannot
 //! drift on a decision without drifting on the plan — which the plan's own
 //! tests pin.
@@ -21,6 +21,7 @@ use std::ffi::CString;
 use std::sync::Once;
 
 use anyhow::{anyhow, Result};
+use inkwell::attributes::{Attribute, AttributeLoc};
 use inkwell::context::Context;
 use inkwell::memory_buffer::MemoryBuffer;
 use inkwell::passes::PassBuilderOptions;
@@ -327,6 +328,91 @@ pub(crate) fn optimize_and_emit_module(
     )
 }
 
+/// Optional pre-optimization escape hatch for unusually large generated
+/// functions.
+///
+/// Dense generated bundles often contain one parser/table initializer that is
+/// large enough to make the `-O1+` middle-end super-linear, alongside hundreds
+/// of ordinary functions that benefit substantially from `-Os`. Routing the
+/// whole codegen unit to `-O0` keeps compilation bounded but also bloats every
+/// ordinary sibling. When this cap is non-zero, only functions above it are
+/// stamped `optnone`+`noinline` before the module pipeline runs. This makes
+/// `PERRY_LL_SIZE_OPT=1` a practical hybrid mode instead of an all-or-nothing
+/// gamble on the largest function in each unit.
+///
+/// Disabled by default while the threshold is calibrated across the bundle
+/// corpus. `PERRY_LL_PREOPT_OPTNONE_INSTRS=N` enables it; `0` disables it.
+const DEFAULT_PREOPT_OPTNONE_INSTRS: usize = 0;
+
+fn preopt_optnone_instr_cap() -> usize {
+    std::env::var("PERRY_LL_PREOPT_OPTNONE_INSTRS")
+        .ok()
+        .and_then(|s| s.trim().parse::<usize>().ok())
+        .unwrap_or(DEFAULT_PREOPT_OPTNONE_INSTRS)
+}
+
+fn stamp_function_optnone(function: inkwell::values::FunctionValue<'_>) {
+    let context = function.get_type().get_context();
+    let optnone_kind = Attribute::get_named_enum_kind_id("optnone");
+    let noinline_kind = Attribute::get_named_enum_kind_id("noinline");
+    // `alwaysinline` and `noinline` are verifier-incompatible. Generated
+    // functions do not normally carry it, but the opt-in must remain safe for
+    // imported/generated IR that does.
+    function.remove_enum_attribute(
+        AttributeLoc::Function,
+        Attribute::get_named_enum_kind_id("alwaysinline"),
+    );
+    function.remove_enum_attribute(
+        AttributeLoc::Function,
+        Attribute::get_named_enum_kind_id("inlinehint"),
+    );
+    function.add_attribute(
+        AttributeLoc::Function,
+        context.create_enum_attribute(optnone_kind, 0),
+    );
+    function.add_attribute(
+        AttributeLoc::Function,
+        context.create_enum_attribute(noinline_kind, 0),
+    );
+}
+
+fn function_instruction_count(function: inkwell::values::FunctionValue<'_>, cap: usize) -> usize {
+    let mut instrs = 0usize;
+    'body: for bb in function.get_basic_blocks() {
+        let mut inst = bb.get_first_instruction();
+        while let Some(i) = inst {
+            instrs += 1;
+            if instrs > cap {
+                break 'body;
+            }
+            inst = i.get_next_instruction();
+        }
+    }
+    instrs
+}
+
+/// Demote large functions before the ordinary optimization pipeline while
+/// leaving every smaller sibling eligible for the unit's requested opt level.
+fn demote_preoptimization_bloated_functions(module: &inkwell::module::Module<'_>, cap: usize) {
+    if cap == 0 {
+        return;
+    }
+    let mut function = module.get_first_function();
+    while let Some(f) = function {
+        if function_instruction_count(f, cap) > cap {
+            stamp_function_optnone(f);
+            eprintln!(
+                "perry: `{}` exceeds {} pre-optimization instructions; compiling only this \
+                 function unoptimized (optnone) while its siblings keep the module's size \
+                 optimization. Override with PERRY_LL_PREOPT_OPTNONE_INSTRS.",
+                f.get_name().to_string_lossy(),
+                cap,
+            );
+        }
+        function = f.get_next_function();
+    }
+}
+
 fn optimize_and_emit(
     module: &inkwell::module::Module<'_>,
     effective_target: &str,
@@ -387,6 +473,12 @@ fn optimize_and_emit(
     module.set_triple(&triple);
     module.set_data_layout(&tm.get_target_data().get_data_layout());
 
+    // Opt-in hybrid size optimization for generated bundles: protect only the
+    // pathological bodies before entering the requested module pipeline.
+    if opt != '0' {
+        demote_preoptimization_bloated_functions(module, preopt_optnone_instr_cap());
+    }
+
     // RS4GC must run BEFORE the optimization pipeline, and — critically — in
     // this process, against this LLVM.
     //
@@ -515,6 +607,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn preoptimization_bloated_function_is_demoted_without_demoting_its_sibling() {
+        global_init(&[]);
+        let context = Context::create();
+        let ir = "define i64 @big(i64 %a) {\n\
+                  entry:\n\
+                  \x20 %x1 = add i64 %a, 1\n\
+                  \x20 %x2 = add i64 %x1, 1\n\
+                  \x20 %x3 = add i64 %x2, 1\n\
+                  \x20 %x4 = add i64 %x3, 1\n\
+                  \x20 %x5 = add i64 %x4, 1\n\
+                  \x20 ret i64 %x5\n\
+                  }\n\
+                  define i64 @small(i64 %a) {\n\
+                  entry:\n\
+                  \x20 %x1 = add i64 %a, 1\n\
+                  \x20 ret i64 %x1\n\
+                  }\n";
+        let module =
+            parse_ir_text(&context, ir, "preopt_optnone_demotion").expect("fixture parses");
+        demote_preoptimization_bloated_functions(&module, 4);
+
+        let optnone_kind = Attribute::get_named_enum_kind_id("optnone");
+        let big = module.get_function("big").expect("big exists");
+        let small = module.get_function("small").expect("small exists");
+        assert!(
+            big.get_enum_attribute(AttributeLoc::Function, optnone_kind)
+                .is_some(),
+            "a function past the pre-optimization cap must be stamped optnone"
+        );
+        assert!(
+            small
+                .get_enum_attribute(AttributeLoc::Function, optnone_kind)
+                .is_none(),
+            "an ordinary sibling must keep the module optimization pipeline"
+        );
+        module
+            .verify()
+            .expect("optnone+noinline must remain verifier-valid");
+    }
+
     fn constant_fold_order_fixture(folded: bool) -> String {
         let mut ir = String::from(
             "declare i64 @may_collect()\n\ndefine i64 @f(i64 %d0, i64 %d1, i64 %d2, i64 %d3, i64 %d4, i64 %d5, i64 %d6, i64 %d7) gc \"statepoint-example\" {\nentry:\n",

crates/perry-codegen/src/linker.rs

@@ -307,6 +307,13 @@ fn cpu_tuning_arg_for(
     }
 }
 
+fn size_optimization_requested(value: Option<&str>) -> bool {
+    value
+        .map(str::trim)
+        .map(str::to_ascii_lowercase)
+        .is_some_and(|value| matches!(value.as_str(), "1" | "true" | "on" | "yes"))
+}
+
 fn build_clang_compile_plan(
     clang: PathBuf,
     ll_path: PathBuf,
@@ -323,11 +330,15 @@ fn build_clang_compile_plan(
         cpu_tuning_arg_for(requested_cpu.as_deref(), target_triple, &effective_target);
     let stderr_remarks_path = PathBuf::from(format!("{}.clang-stderr", obj_path.display()));
 
-    // Perry promises speed-optimized native output. Large modules/functions
-    // stay at -O3 too; compile-time scalability belongs in codegen-unit
-    // partitioning and structured function outlining, not in a silent change
-    // to the runtime optimization policy.
-    let opt_flag = "-O3";
+    // Perry defaults to speed-optimized native output. Generated-bundle users
+    // can explicitly trade runtime speed for artifact size with
+    // PERRY_LL_SIZE_OPT; there is no module-size-driven policy change.
+    let size_opt = env::var("PERRY_LL_SIZE_OPT").ok();
+    let opt_flag = if size_optimization_requested(size_opt.as_deref()) {
+        "-Os"
+    } else {
+        "-O3"
+    };
 
     // Compacting the stack map means going through assembly, because that is
     // where LLVM prints the map's function addresses as symbol *names* — the
@@ -372,7 +383,7 @@ fn build_clang_compile_plan(
     clang_args.push("-target".to_string());
     clang_args.push(effective_target.clone());
 
-    let mut analysis_clang_args = vec!["-O3".to_string(), "-fno-math-errno".to_string()];
+    let mut analysis_clang_args = vec![opt_flag.to_string(), "-fno-math-errno".to_string()];
     if let Some(arg) = &native_tuning_arg {
         analysis_clang_args.push(arg.clone());
     }

crates/perry-codegen/src/linker_tests.rs

@@ -167,7 +167,7 @@ fn compile_plan_records_effective_target_and_native_tuning() {
         false,
     );
     assert!(plan.clang_args.contains(&"-fno-math-errno".to_string()));
-    // Native compilation is always speed-optimized at -O3.
+    // Native compilation defaults to speed-optimized -O3.
     assert!(plan.clang_args.contains(&"-O3".to_string()));
     assert!(plan.clang_args.contains(&"-target".to_string()));
     assert!(plan.analysis_clang_args.contains(&"-target".to_string()));
@@ -185,7 +185,7 @@ fn compile_plan_records_effective_target_and_native_tuning() {
 }
 
 #[test]
-fn compile_plan_always_uses_o3() {
+fn compile_plan_defaults_to_o3() {
     // Module size is deliberately absent from the compile plan: Perry's
     // runtime optimization contract does not change for large generated IR.
     // Scalability is handled by codegen-unit partitioning and structured
@@ -203,6 +203,17 @@ fn compile_plan_always_uses_o3() {
     assert!(!plan.clang_args.contains(&"-O0".to_string()));
 }
 
+#[test]
+fn size_optimization_flag_is_explicit_and_truthy() {
+    for enabled in ["1", "true", "TRUE", " on ", "yes"] {
+        assert!(size_optimization_requested(Some(enabled)), "{enabled}");
+    }
+    for disabled in ["", "0", "false", "off", "no", "anything-else"] {
+        assert!(!size_optimization_requested(Some(disabled)), "{disabled}");
+    }
+    assert!(!size_optimization_requested(None));
+}
+
 #[test]
 fn compile_plan_skips_native_tuning_for_explicit_target() {
     let plan = build_clang_compile_plan(

crates/perry/src/commands/compile/build_cache.rs

@@ -39,6 +39,10 @@ const BUILD_CACHE_ENV_VARS: &[&str] = &[
     "PERRY_WRITE_BARRIERS",
     "PERRY_SHADOW_STACK",
     "PERRY_RS4GC",
+    // Explicit hybrid size mode changes both the module optimization policy
+    // and which unusually large functions skip the middle-end.
+    "PERRY_LL_SIZE_OPT",
+    "PERRY_LL_PREOPT_OPTNONE_INSTRS",
     "PERRY_GC_SAFEPOINT_ONLY",
     "PERRY_INLINE_SHADOW_SLOT",
     "PERRY_DISABLE_BUFFER_FAST_PATH",

crates/perry/src/commands/compile/collect_modules.rs

@@ -33,6 +33,7 @@ mod dynamic_glob;
 mod eval_worker;
 mod feature_detect;
 mod import_helpers;
+mod json_module;
 mod native_addon;
 mod parse_error;
 mod script_string;
@@ -51,6 +52,7 @@ pub(super) use import_helpers::known_node_submodule_key;
 use import_helpers::{
     cached_resolve_import_with_lexical_base, collect_js_module_imports, env_defines_for_lowering,
 };
+use json_module::synthesize_json_module;
 pub(super) use native_addon::package_has_unsupported_node_addon;
 use native_addon::{refuse_compile_package_native_addon, refuse_node_addon_binary};
 use parse_error::annotate_parse_error;
@@ -346,24 +348,9 @@ fn collect_module_one(
             .map_err(|e| anyhow!("Failed to read {}: {}", canonical.display(), e))?
     };
     // JSON module import: turn the data file into a native ESM module whose
-    // default export is the parsed value. JSON is a syntactic subset of a JS
-    // expression, so `export default <json>;` parses and lowers like any other
-    // module. Validate as JSON first so a malformed file yields a clear error
-    // rather than a confusing TS parse failure on the synthesized source.
+    // default export is the parsed value.
     let raw_source = if is_json {
-        if let Err(e) = serde_json::from_str::<serde_json::Value>(&raw_source) {
-            return Err(anyhow!(
-                "Failed to parse JSON module {}: {}",
-                canonical.display(),
-                e
-            ));
-        }
-        let json_value = "__perry_json_default";
-        format!(
-            "function __perry_json_factory() {{ return {}; }}\nconst {json_value} = __perry_json_factory();\nconst __perry_json_module = {{ __perry_cjs_record: true, __perry_cjs_factory: __perry_json_factory, exports: {json_value}, loaded: false }};\n__perry_register_path_module({:?}, __perry_json_module);\nexport default {json_value};\n",
-            raw_source.trim(),
-            canonical.to_string_lossy(),
-        )
+        synthesize_json_module(&raw_source, &canonical)?
     } else if is_text_asset {
         // #5223: text-asset import. The file's contents are exposed verbatim as
         // the module's default export (a JS string). We never TS-parse the raw

crates/perry/src/commands/compile/collect_modules/json_module.rs

@@ -0,0 +1,64 @@
+//! JSON-module source synthesis.
+//!
+//! Keep JSON as a serialized string until runtime. Lowering a large JSON object
+//! literal emits an allocation and property-store sequence for every member;
+//! data sets such as `mime-db` consequently produced megabytes of machine code.
+
+use anyhow::{anyhow, Result};
+use std::path::Path;
+
+pub(super) fn synthesize_json_module(raw: &str, canonical: &Path) -> Result<String> {
+    serde_json::from_str::<serde_json::Value>(raw).map_err(|error| {
+        anyhow!(
+            "Failed to parse JSON module {}: {}",
+            canonical.display(),
+            error
+        )
+    })?;
+
+    // serde_json's string serializer produces a valid JavaScript literal and
+    // escapes control characters, quotes, backslashes, and line separators.
+    let serialized = serde_json::to_string(raw.trim()).map_err(|error| {
+        anyhow!(
+            "Failed to encode JSON module {}: {}",
+            canonical.display(),
+            error
+        )
+    })?;
+    let path = canonical.to_string_lossy();
+
+    Ok(format!(
+        "function __perry_json_factory() {{ return JSON.parse({serialized}); }}\n\
+         const __perry_json_default = __perry_json_factory();\n\
+         const __perry_json_module = {{ __perry_cjs_record: true, __perry_cjs_factory: __perry_json_factory, exports: __perry_json_default, loaded: false }};\n\
+         __perry_register_path_module({path:?}, __perry_json_module);\n\
+         export default __perry_json_default;\n"
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::synthesize_json_module;
+    use std::path::Path;
+
+    #[test]
+    fn keeps_json_serialized_instead_of_lowering_an_object_literal() {
+        let source = synthesize_json_module(
+            r#"{"items":[1,true,null],"nested":{"message":"hello"}}"#,
+            Path::new("data.json"),
+        )
+        .expect("synthesize JSON module");
+
+        assert!(source.contains("return JSON.parse("));
+        assert!(!source.contains("return {\"items\""));
+        assert!(source.contains("export default __perry_json_default"));
+    }
+
+    #[test]
+    fn rejects_invalid_json_before_typescript_parsing() {
+        let error = synthesize_json_module("{broken", Path::new("broken.json"))
+            .expect_err("invalid JSON should fail");
+        assert!(error.to_string().contains("Failed to parse JSON module"));
+        assert!(error.to_string().contains("broken.json"));
+    }
+}

crates/perry/src/commands/compile/object_cache.rs

@@ -830,6 +830,16 @@ fn compute_object_cache_key_with_env(
         env_var("PERRY_SHADOW_STACK").as_deref().unwrap_or(""),
     );
     h.field("env_rs4gc", env_var("PERRY_RS4GC").as_deref().unwrap_or(""));
+    h.field(
+        "env_ll_size_opt",
+        env_var("PERRY_LL_SIZE_OPT").as_deref().unwrap_or(""),
+    );
+    h.field(
+        "env_ll_preopt_optnone_instrs",
+        env_var("PERRY_LL_PREOPT_OPTNONE_INSTRS")
+            .as_deref()
+            .unwrap_or(""),
+    );
     // Explicit-safepoint contract: flips audited AllocNoReentry helpers
     // between statepoint and plain call. Two arms sharing a cached object
     // would make the contract's metadata reduction unmeasurable.