lib/choir/src/backends/wasm/emission/plan/root.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const binary = @import("../../binary/root.zig");
 2 const ir = @import("../../../../core/root.zig");
 3 const emission = @import("../root.zig");
 4 
 5 pub const index = @import("index.zig");
 6 pub const planning = @import("planning.zig");
 7 
 8 pub const FunctionPlan = struct {
 9     name: []const u8,
10     value_start: u32,
11     value_count: u32,
12     param_count: u32,
13     local_count: u32,
14     function_index: u32,
15     body_bytes: usize,
16 };
17 
18 pub const ValuePlan = struct {
19     value: *ir.Value,
20     local_index: u32,
21     value_type: binary.ValueType,
22 };
23 
24 pub const Plan = struct {
25     functions: []FunctionPlan,
26     function_index: []u32,
27     values: []ValuePlan,
28     value_index: []u32,
29     import_count: usize,
30     definition_count: usize,
31     needs_memory: bool,
32     sections: emission.SectionSizes,
33 
34     pub fn functionIndex(self: *const Plan, name: []const u8) ?u32 {
35         return index.findFunction(self.function_index, self.functions, name);
36     }
37 
38     pub fn localFor(self: *const Plan, function_ordinal: usize, value: *ir.Value) ?u32 {
39         if (function_ordinal >= self.functions.len) return null;
40         return index.findLocal(
41             self.value_index,
42             self.values,
43             self.functions[function_ordinal],
44             value,
45         );
46     }
47 
48     pub fn localPlans(self: *const Plan, function_ordinal: usize) []const ValuePlan {
49         const function_plan = self.functions[function_ordinal];
50         const start: usize = function_plan.value_start + function_plan.param_count;
51         const end = start + function_plan.local_count;
52         return self.values[start..end];
53     }
54 
55     pub fn functionCount(self: *const Plan) usize {
56         return self.functions.len;
57     }
58 
59     pub fn importCount(self: *const Plan) usize {
60         return self.import_count;
61     }
62 
63     pub fn definitionCount(self: *const Plan) usize {
64         return self.definition_count;
65     }
66 
67     pub fn localCount(self: *const Plan, function_ordinal: usize) usize {
68         return self.functions[function_ordinal].local_count;
69     }
70 
71     pub fn bodyBytes(self: *const Plan, function_ordinal: usize) usize {
72         return self.functions[function_ordinal].body_bytes;
73     }
74 
75     pub fn needsMemory(self: *const Plan) bool {
76         return self.needs_memory;
77     }
78 };