Documentation

Calculate the wasm representation type from a CmmType. This is a lossy conversion, and sometimes we need to pass the original CmmType or at least its Width around, so to properly add subword truncation or extension logic.

Calculate the optional memory narrowing of a CmmLoad or CmmStore.

Despite this is used by the WebAssembly native codegen, we use pprCLabel instead of pprAsmLabel when emitting the textual symbol name. Either one would work, but pprCLabel makes the output assembly code looks closer to the unregisterised codegen output, which can be handy when using the unregisterised codegen as a source of truth when debugging the native codegen.

Calculate a symbol's visibility.

Calculate a symbol's kind, see haddock docs of SymKind for more explanation.

Calculate a data section's kind, see haddock docs of DataSectionKind for more explanation.

Calculate the natural alignment size given the platform word type.

Calculate a data section's alignment. Closures needs to be naturally aligned; info tables need to align to 2, so to get 1 tag bit as forwarding pointer marker. The rest have no alignment requirements.

Lower a CmmStatic.

Allocate a fresh symbol for an internal data section.

Print a debug message to stderr by calling fputs(). We don't bother to check fputs() return value.

Truncate a subword.

Sign-extend a subword.

Lower a binary homogeneous operation. Homogeneous: result type is the same with operand types.

Lower a binary homogeneous operation, and truncate the result if it's a subword.

Lower a binary homogeneous operation, first sign extending the operands, then truncating the result.

Lower a relational binary operation, first sign extending the operands. Relational: result type is a boolean (word type).

Lower a relational binary operation.

Cast a shiftL/shiftR RHS to the same type as LHS. Because we may have a 64-bit LHS and 32-bit RHS, but wasm shift operators are homogeneous.

Lower a MO_Shl operation, truncating the result.

Lower a MO_U_Shr operation.

Lower a MO_S_Shr operation, first sign-extending the LHS, then truncating the result.

Lower a MO_MulMayOflo operation. It's translated to a ccall to hs_mulIntMayOflo function in ghc-primcbitsmulIntMayOflo, otherwise it's quite non-trivial to implement as inline assembly.

Lower an unary conversion operation.

Lower a MO_SS_Conv operation.

Lower a MO_UU_Conv operation.

Lower a MO_FF_Conv operation.

Lower a CmmMachOp.

Lower a CmmLit. Note that we don't emit 'f32.const' or 'f64.const' for the time being, and instead emit their relative bit pattern as int literals, then use an reinterpret cast. This is simpler than dealing with textual representation of floating point values.

Lower a CmmRegOff.

Lower a CmmLoad, passing in the expected wasm representation type, and also the Cmm type (which contains width info needed for memory narrowing).

The Cmm type system doesn't track signedness, so all CmmLoads are unsigned loads. However, as an optimization, we do emit signed loads when a CmmLoad result is immediately used as a MO_SS_Conv operand.

Lower a CmmLoad.

Lower a CmmExpr.

Lower a CmmExpr, passing in the expected wasm representation type.

Lower a CmmExpr as a pointer, returning the pair of base pointer and non-negative offset.

Push a series of values onto the wasm value stack, returning the result stack type.

Push the arguments onto the wasm value stack before a ccall.

Pop the results into locals after a ccall.

Lower an unary homogeneous CallishMachOp to a ccall.

Lower an unary homogeneous CallishMachOp to inline assembly.

Lower a binary homogeneous CallishMachOp to a ccall.

Lower a MO_UF_Conv operation.

Lower a MO_Cmpxchg operation to inline assembly. Currently we target wasm without atomics and threads, so it's just lowered to regular memory loads and stores.

Lower a CallishMachOp.

Lower a ccall, but drop the result by assigning it to an unused local. This is only used for lowering MO_Memcpy and such, where the libc functions do have a return value, but the corresponding CallishMachOp does not expect one.

Lower a CmmUnsafeForeignCall. The target is Either a symbol, which translates to a direct call, or an expression, which translates to a call_indirect. The callee function signature is inferred from the passed in arguments here.

Lower a CmmStore.

Lower a single Cmm action.

Lower a block of Cmm actions.

Lower a GenCmmGraph.

Invoked once for each CLabel which indexes a CmmData or CmmProc.

Invoked for each function CLabel with known type (e.g. a CmmProc, or callee of CmmUnsafeForeignCall).

Invoked for all other CLabels along the way, e.g. in CmmStatics or CmmExprs.

Invoked for each LocalReg, returning its wasm local id and representation type.

Invoked for each LocalReg with expected representation type, only returning its wasm local id.

Invoked for dtors. We don't bother to implement dtors yet; there's no native .fini_array support for wasm, and the way clang handles dtors is generating a ctor that calls atexit() for dtors. Which makes some sense, but we don't need to do the same thing yet.

Invoked for ctors and dtors.

Invoked for each data section.

Invoked for each CmmProc.

Invoked for each RawCmmDecl.

Invoked for each RawCmmGroup.