Retrieve SourceLocation of caller when an Appl has signature mismatch

Author: btzy

lib-backend-wasm/src/func.rs

@@ -21,7 +21,7 @@ use boolinator::*;
 
 use std::collections::HashMap;
 
-struct EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap: HeapManager> {
+struct EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, Heap: HeapManager> {
     // Local to this function
     return_type: Option<ir::VarType>,
 
@@ -38,19 +38,20 @@ struct EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap: HeapManager> {
     stackptr: wasmgen::GlobalIdx,
     memidx: wasmgen::MemIdx,
     thunk_map: &'f HashMap<Box<[ir::OverloadEntry]>, u32>, // map from overloads to elemidx
-    heap: &'g Heap,
-    string_pool: &'h ShiftedStringPool,
+    appl_data_encoder: &'g HashMap<ir::SourceLocation, u32>, // map from source location to the location in memory of the args
+    heap: &'h Heap,
+    string_pool: &'i ShiftedStringPool,
     error_func: wasmgen::FuncIdx, // imported function to call to error out (e.g. runtime type errors)
     options: Options,             // Compilation options (it implements Copy)
 }
 
 // Have to implement Copy and Clone manually, because #[derive(Copy, Clone)] doesn't work for generic types like Heap
-impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap: HeapManager> Copy
-    for EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap>
+impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, Heap: HeapManager> Copy
+    for EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, Heap>
 {
 }
-impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap: HeapManager> Clone
-    for EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, Heap>
+impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, Heap: HeapManager> Clone
+    for EncodeContext<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, Heap>
 {
     fn clone(&self) -> Self {
         *self
@@ -106,14 +107,14 @@ pub fn encode_funcs<'a, Heap: HeapManager>(
     globalidx_stackptr: wasmgen::GlobalIdx,
     memidx: wasmgen::MemIdx,
     thunk_sv: SearchableVec<Box<[ir::OverloadEntry]>>,
+    appl_data_encoder: HashMap<ir::SourceLocation, u32>,
     heap: &Heap,
     string_pool: &ShiftedStringPool,
     error_func: wasmgen::FuncIdx,
     options: Options,
     wasm_module: &mut wasmgen::WasmModule,
 ) {
     struct WasmRegistry {
-        typeidx: wasmgen::TypeIdx,
         funcidx: wasmgen::FuncIdx,
         wasm_param_map: Box<[wasmgen::LocalIdx]>, // map converts wasm_param_map index to actual wasm param index
         param_map: Box<[usize]>, // map converts ir param index to wasm_param_map index
@@ -140,11 +141,10 @@ pub fn encode_funcs<'a, Heap: HeapManager>(
                     wasm_param_valtypes,
                     encode_result(ir_func.result, options.wasm_multi_value),
                 );
-                let (wasm_typeidx, wasm_funcidx) = wasm_module.register_func(&wasm_functype);
+                let (_, wasm_funcidx) = wasm_module.register_func(&wasm_functype);
                 let code_builder = wasmgen::CodeBuilder::new(wasm_functype);
                 (
                     WasmRegistry {
-                        typeidx: wasm_typeidx,
                         funcidx: wasm_funcidx,
                         wasm_param_map: wasm_param_map,
                         param_map: param_map,
@@ -194,6 +194,7 @@ pub fn encode_funcs<'a, Heap: HeapManager>(
                     memidx: memidx,
                     heap: heap,
                     thunk_map: &new_thunk_map,
+                    appl_data_encoder: &appl_data_encoder,
                     string_pool: string_pool,
                     error_func: error_func,
                     options: options,
@@ -240,6 +241,7 @@ pub fn encode_funcs<'a, Heap: HeapManager>(
                     memidx: memidx,
                     heap: heap,
                     thunk_map: &new_thunk_map,
+                    appl_data_encoder: &appl_data_encoder,
                     string_pool: string_pool,
                     error_func: error_func,
                     options: options,
@@ -757,9 +759,21 @@ fn encode_expr<H: HeapManager>(
             encode_prim_inst(expr.vartype, *prim_inst, args, ctx, mutctx, expr_builder);
             true
         }
-        ir::ExprKind::Appl { func, args } => {
+        ir::ExprKind::Appl {
+            func,
+            args,
+            location,
+        } => {
             // encodes an indirect function call
-            encode_appl(expr.vartype, func, args, ctx, mutctx, expr_builder);
+            encode_appl(
+                expr.vartype,
+                func,
+                args,
+                location,
+                ctx,
+                mutctx,
+                expr_builder,
+            );
             true
         }
         ir::ExprKind::DirectAppl { funcidx, args } => {
@@ -1227,6 +1241,7 @@ fn encode_appl<H: HeapManager>(
     return_type: Option<ir::VarType>,
     func_expr: &ir::Expr,
     args: &[ir::Expr],
+    location: &ir::SourceLocation,
     ctx: EncodeContext<H>,
     mutctx: &mut MutContext,
     expr_builder: &mut wasmgen::ExprBuilder,
@@ -1269,10 +1284,9 @@ fn encode_appl<H: HeapManager>(
             expr_builder,
         );
 
-        // TODO: encode the proper caller id
-        // for now just use zero
+        // encode the proper caller id (which is the memory location of the SourceLocation)
         // net wasm stack: [] -> [i32(callerid)]
-        expr_builder.i32_const(0);
+        expr_builder.i32_const(*ctx.appl_data_encoder.get(location).unwrap() as i32);
 
         // push the tableidx onto the stack
         // net wasm stack: [] -> [tableidx]
@@ -1921,14 +1935,23 @@ fn encode_thunk<H: HeapManager>(
         sourceloc_ref: wasmgen::LocalIdx,
         expr_builder: &mut wasmgen::ExprBuilder,
     ) {
+        // we need to fetch the actual source location from the static memory to set as arguments of the error_func
         expr_builder.i32_const(ir::error::ERROR_CODE_FUNCTION_PARAM_TYPE as i32);
         expr_builder.i32_const(0);
-        expr_builder.i32_const(0); // todo!(add actual source location)
-        expr_builder.i32_const(0);
-        expr_builder.i32_const(0);
-        expr_builder.i32_const(0);
-        expr_builder.i32_const(0);
+        // the source location is 5 of u32s
+        expr_builder.local_get(sourceloc_ref);
+        expr_builder.i32_load(wasmgen::MemArg::new4(0));
+        expr_builder.local_get(sourceloc_ref);
+        expr_builder.i32_load(wasmgen::MemArg::new4(4));
+        expr_builder.local_get(sourceloc_ref);
+        expr_builder.i32_load(wasmgen::MemArg::new4(8));
+        expr_builder.local_get(sourceloc_ref);
+        expr_builder.i32_load(wasmgen::MemArg::new4(12));
+        expr_builder.local_get(sourceloc_ref);
+        expr_builder.i32_load(wasmgen::MemArg::new4(16));
+        // call the error_func with 7 arguments
         expr_builder.call(error_func);
+        // the error func is noreturn, so we want to tell wasm that it is indeed noreturn
         expr_builder.unreachable();
     }
 }

lib-backend-wasm/src/lib.rs

@@ -189,16 +189,25 @@ fn encode_program(ir_program: &ir::Program, options: Options) -> wasmgen::WasmMo
     let pre_traverse::TraverseResult {
         string_pool,
         thunk_sv,
+        appl_location_sv,
     } = pre_traverse::pre_traverse_funcs(&ir_program.funcs);
 
-    let (shifted_string_pool, mut pool_data) =
+    let (shifted_string_pool, pool_data) =
         string_pool.into_shifted_and_buffer(MEM_STACK_SIZE << WASM_PAGE_BITS);
-    // round up to multiple of WASM_PAGE_SIZE
-    let required_data_size =
-        ((pool_data.len() as u32) + (WASM_PAGE_SIZE - 1)) & (!(WASM_PAGE_SIZE - 1));
-    pool_data.resize(required_data_size as usize, 0);
-    // in terms of WASM_PAGE_SIZE
-    let globals_num_pages: u32 = required_data_size >> WASM_PAGE_BITS;
+
+    assert!(pool_data.len() & 3 == 0); // assert that it is at 4-byte boundary
+
+    // make static data for appl locations
+    let (appl_data, appl_data_encoder) = pre_traverse::make_appl_location_static_data(
+        appl_location_sv,
+        (MEM_STACK_SIZE << WASM_PAGE_BITS) + pool_data.len() as u32,
+    );
+
+    assert!(appl_data.len() & 3 == 0); // assert that it is at 4-byte boundary
+
+    // in terms of WASM_PAGE_SIZE (rounded up to nearest page boundary)
+    let globals_num_pages: u32 =
+        ((pool_data.len() + appl_data.len()) as u32 + (WASM_PAGE_SIZE - 1)) >> WASM_PAGE_BITS;
 
     // add linear memory
     let memidx: wasmgen::MemIdx = encode_mem(
@@ -214,13 +223,21 @@ fn encode_program(ir_program: &ir::Program, options: Options) -> wasmgen::WasmMo
     wasm_module.export_mem(memidx, "linear_memory".to_string());
 
     // initialize pool data
-    encode_pool_data(
+    encode_static_data(
         &pool_data,
         MEM_STACK_SIZE << WASM_PAGE_BITS,
         memidx,
         &mut wasm_module,
     );
 
+    // initialize appl data
+    encode_static_data(
+        &appl_data,
+        (MEM_STACK_SIZE << WASM_PAGE_BITS) + pool_data.len() as u32,
+        memidx,
+        &mut wasm_module,
+    );
+
     // garbage collector
     let heap = Cheney::new(
         &ir_program.struct_types,
@@ -259,6 +276,7 @@ fn encode_program(ir_program: &ir::Program, options: Options) -> wasmgen::WasmMo
         globalidx_stackptr,
         memidx,
         thunk_sv,
+        appl_data_encoder,
         &heap,
         &shifted_string_pool,
         error_func,
@@ -306,7 +324,7 @@ fn encode_mem(num_pages: u32, wasm_module: &mut wasmgen::WasmModule) -> wasmgen:
     wasm_module.add_unbounded_memory(num_pages)
 }
 
-fn encode_pool_data(
+fn encode_static_data(
     pool_data: &[u8],
     offset: u32,
     memidx: wasmgen::MemIdx,

lib-backend-wasm/src/pre_traverse.rs

@@ -23,16 +23,17 @@ pub struct ShiftedStringPool {
 #[derive(Default)]
 pub struct TraverseResult {
     pub string_pool: StringPool,
-    //pub addressed_funcs: SearchableVec<ir::FuncIdx>, // list of functions called by PrimFunc
     // map from [FuncIdx] to tableidx, since [FuncIdx] uniquely determines the thunk content
     // (note: we can know the signature from the funcidx)
     pub thunk_sv: SearchableVec<Box<[ir::OverloadEntry]>>,
+    pub appl_location_sv: SearchableVec<ir::SourceLocation>,
 }
 
 /*
 Traverses the IR to:
 - put all string constants in a string pool, and encodes the static data buffer
-- put all addressed functions in a vector
+- put all overload sets (thunks) in a SearchableVec
+- extract all SourceLocations in Appls into a SearchableVec
 */
 pub fn pre_traverse_funcs(funcs: &[ir::Func]) -> TraverseResult {
     let mut res = TraverseResult::default();
@@ -80,9 +81,14 @@ fn pre_traverse_expr_kind(expr_kind: &ir::ExprKind, res: &mut TraverseResult) {
         }
         ir::ExprKind::VarName { source: _ } => {}
         ir::ExprKind::PrimAppl { prim_inst: _, args } => pre_traverse_exprs(args, res),
-        ir::ExprKind::Appl { func, args } => {
+        ir::ExprKind::Appl {
+            func,
+            args,
+            location,
+        } => {
             pre_traverse_expr(func, res);
             pre_traverse_exprs(args, res);
+            res.appl_location_sv.insert_copy(location);
         }
         ir::ExprKind::DirectAppl { funcidx: _, args } => pre_traverse_exprs(args, res),
         ir::ExprKind::Conditional {
@@ -172,3 +178,29 @@ impl ShiftedStringPool {
         *self.map.get(str).unwrap()
     }
 }
+
+// encodes the appl_location_sv into static data
+// returns the data and the map from the SourceLocation to the index in memory (using the given `offset` to adjust this index)
+pub fn make_appl_location_static_data(
+    appl_location_sv: SearchableVec<ir::SourceLocation>,
+    offset: u32,
+) -> (Box<[u8]>, HashMap<ir::SourceLocation, u32>) {
+    let (v, hm) = appl_location_sv.into_parts();
+    let mut ret_bytes = Vec::new();
+    // 4 bytes per u32, and 5 u32 to specify the location, so 20 bytes per iterm
+    let ret_len = v.len() * 20;
+    ret_bytes.reserve_exact(ret_len);
+    for sl in v {
+        ret_bytes.extend_from_slice(&sl.file.to_le_bytes());
+        ret_bytes.extend_from_slice(&sl.start.line.to_le_bytes());
+        ret_bytes.extend_from_slice(&sl.start.column.to_le_bytes());
+        ret_bytes.extend_from_slice(&sl.end.line.to_le_bytes());
+        ret_bytes.extend_from_slice(&sl.end.column.to_le_bytes());
+    }
+    assert!(ret_bytes.len() == ret_len);
+    let ret_hm: HashMap<ir::SourceLocation, u32> = hm
+        .into_iter()
+        .map(|(sl, idx)| (sl, offset + (idx as u32) * 20))
+        .collect();
+    (ret_bytes.into_boxed_slice(), ret_hm)
+}

lib-frontend-estree/src/func/post_parse.rs

@@ -1695,7 +1695,6 @@ fn post_parse_varname(
             // it's a direct, so we have to synthesise a wrapper func for it
             post_parse_direct_varname(
                 es_id.name.as_str(),
-                loc,
                 parse_ctx,
                 depth,
                 num_locals,
@@ -1708,7 +1707,6 @@ fn post_parse_varname(
 
 fn post_parse_direct_varname(
     name: &str,
-    _loc: Option<esSL>,
     parse_ctx: &mut ParseState,
     _depth: usize,
     _num_locals: usize, // current number of IR locals
@@ -2012,6 +2010,7 @@ fn post_parse_call_expr(
     };
     post_parse_call_func_with_params_helper(
         func,
+        loc,
         es_call_expr.arguments.into_iter(),
         parse_ctx,
         depth,
@@ -2023,6 +2022,7 @@ fn post_parse_call_expr(
 
 fn post_parse_call_func_with_params_helper(
     func_expr: ir::Expr,
+    loc: Option<esSL>,
     args_iter: impl ExactSizeIterator<Item = Node> + DoubleEndedIterator<Item = Node>,
     parse_ctx: &mut ParseState,
     depth: usize,
@@ -2038,6 +2038,7 @@ fn post_parse_call_func_with_params_helper(
         kind: ir::ExprKind::Appl {
             func: Box::new(func_expr),
             args: args,
+            location: as_ir_sl(&loc, 0 /*FILE*/),
         },
     })
 }
@@ -2056,11 +2057,12 @@ fn post_parse_direct_call_helper(
     // IR should propage constants in order to convert this to a real direct call (perhaps by considering cases based on the param types here)
 
     let primfunc_expr: ir::Expr = post_parse_direct_varname(
-        func_name, loc, parse_ctx, depth, num_locals, filename, ir_program,
+        func_name, parse_ctx, depth, num_locals, filename, ir_program,
     )?;
 
     post_parse_call_func_with_params_helper(
         primfunc_expr,
+        loc,
         Vec::from(params).into_iter(),
         parse_ctx,
         depth,
@@ -2169,7 +2171,7 @@ fn as_ir_sl(opt_es_sl: &Option<SourceLocation>, fileidx: u32) -> ir::SourceLocat
             },
             ir::Position {
                 line: es_sl.end.line as u32,
-                column: es_sl.start.column as u32,
+                column: es_sl.end.column as u32,
             },
         ),
         None => (

lib-ir/src/lib.rs

@@ -191,6 +191,7 @@ pub enum ExprKind {
     Appl {
         func: Box<Expr>,
         args: Box<[Expr]>,
+        location: SourceLocation, // will be displayed in the error message if the signature mismatches
     }, // function application (operators are functions too).  Closure parameter is implicitly prepended to the argument list.  Called using Source indirect calling convention (closure, length, and callerid as i32 params; others are Any and on unprotected stack). Static type of func must be func.
     DirectAppl {
         funcidx: FuncIdx,
@@ -225,7 +226,7 @@ pub enum ExprKind {
     }, // returns the value of the last expression, or `undefined` if there are zero expressions
     Trap {
         code: u32,
-        location: SourceLocation,
+        location: SourceLocation, // will be displayed in the error message
     }, // has Void type
 }
 
@@ -285,7 +286,7 @@ pub enum Builtin {
 }
 pub const NUM_BUILTINS: u8 = Builtin::UnaryMinus as u8 + 1;
 
-#[derive(Default, Debug, Copy, Clone)]
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct Position {
     pub line: u32,
     pub column: u32,
@@ -294,7 +295,7 @@ pub struct Position {
 /*
 Represents a location in a source file.
 */
-#[derive(Default, Debug, Copy, Clone)]
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct SourceLocation {
     pub file: u32,
     pub start: Position,