diff options
Diffstat (limited to 'src/parser/contexts.h')
| -rw-r--r-- | src/parser/contexts.h | 954 |
1 files changed, 734 insertions, 220 deletions
diff --git a/src/parser/contexts.h b/src/parser/contexts.h index d2f0ea2d0..6505d11a4 100644 --- a/src/parser/contexts.h +++ b/src/parser/contexts.h @@ -355,20 +355,32 @@ struct NullInstrParserCtx { MemargT getMemarg(uint64_t, uint32_t) { return Ok{}; } template<typename BlockTypeT> - Result<> makeBlock(Index, std::optional<Name>, BlockTypeT) { + Result<> makeBlock(Index, + const std::vector<Annotation>&, + std::optional<Name>, + BlockTypeT) { return Ok{}; } template<typename BlockTypeT> - Result<> makeIf(Index, std::optional<Name>, BlockTypeT) { + Result<> makeIf(Index, + const std::vector<Annotation>&, + std::optional<Name>, + BlockTypeT) { return Ok{}; } Result<> visitElse() { return Ok{}; } template<typename BlockTypeT> - Result<> makeLoop(Index, std::optional<Name>, BlockTypeT) { + Result<> makeLoop(Index, + const std::vector<Annotation>&, + std::optional<Name>, + BlockTypeT) { return Ok{}; } template<typename BlockTypeT> - Result<> makeTry(Index, std::optional<Name>, BlockTypeT) { + Result<> makeTry(Index, + const std::vector<Annotation>&, + std::optional<Name>, + BlockTypeT) { return Ok{}; } Result<> visitCatch(Index, TagIdxT) { return Ok{}; } @@ -383,198 +395,427 @@ struct NullInstrParserCtx { CatchT makeCatchAll(LabelIdxT) { return Ok{}; } CatchT makeCatchAllRef(LabelIdxT) { return Ok{}; } template<typename BlockTypeT> - Result<> makeTryTable(Index, std::optional<Name>, BlockTypeT, CatchListT) { + Result<> makeTryTable(Index, + const std::vector<Annotation>&, + std::optional<Name>, + BlockTypeT, + CatchListT) { return Ok{}; } TagLabelListT makeTagLabelList() { return Ok{}; } void appendTagLabel(TagLabelListT&, TagIdxT, LabelIdxT) {} - Result<> makeUnreachable(Index) { return Ok{}; } - Result<> makeNop(Index) { return Ok{}; } - Result<> makeBinary(Index, BinaryOp) { return Ok{}; } - Result<> makeUnary(Index, UnaryOp) { return Ok{}; } - template<typename ResultsT> Result<> makeSelect(Index, ResultsT*) { + void setSrcLoc(const Annotation&) {} + + Result<> makeUnreachable(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> makeNop(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeBinary(Index, const std::vector<Annotation>&, BinaryOp) { + return Ok{}; + } + Result<> makeUnary(Index, const std::vector<Annotation>&, UnaryOp) { + return Ok{}; + } + template<typename ResultsT> + Result<> makeSelect(Index, const std::vector<Annotation>&, ResultsT*) { + return Ok{}; + } + Result<> makeDrop(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeMemorySize(Index, const std::vector<Annotation>&, MemoryIdxT*) { + return Ok{}; + } + Result<> makeMemoryGrow(Index, const std::vector<Annotation>&, MemoryIdxT*) { + return Ok{}; + } + Result<> makeLocalGet(Index, const std::vector<Annotation>&, LocalIdxT) { + return Ok{}; + } + Result<> makeLocalTee(Index, const std::vector<Annotation>&, LocalIdxT) { + return Ok{}; + } + Result<> makeLocalSet(Index, const std::vector<Annotation>&, LocalIdxT) { + return Ok{}; + } + Result<> makeGlobalGet(Index, const std::vector<Annotation>&, GlobalIdxT) { + return Ok{}; + } + Result<> makeGlobalSet(Index, const std::vector<Annotation>&, GlobalIdxT) { return Ok{}; } - Result<> makeDrop(Index) { return Ok{}; } - Result<> makeMemorySize(Index, MemoryIdxT*) { return Ok{}; } - Result<> makeMemoryGrow(Index, MemoryIdxT*) { return Ok{}; } - Result<> makeLocalGet(Index, LocalIdxT) { return Ok{}; } - Result<> makeLocalTee(Index, LocalIdxT) { return Ok{}; } - Result<> makeLocalSet(Index, LocalIdxT) { return Ok{}; } - Result<> makeGlobalGet(Index, GlobalIdxT) { return Ok{}; } - Result<> makeGlobalSet(Index, GlobalIdxT) { return Ok{}; } - Result<> makeI32Const(Index, uint32_t) { return Ok{}; } - Result<> makeI64Const(Index, uint64_t) { return Ok{}; } - Result<> makeF32Const(Index, float) { return Ok{}; } - Result<> makeF64Const(Index, double) { return Ok{}; } - Result<> makeI8x16Const(Index, const std::array<uint8_t, 16>&) { + Result<> makeI32Const(Index, const std::vector<Annotation>&, uint32_t) { + return Ok{}; + } + Result<> makeI64Const(Index, const std::vector<Annotation>&, uint64_t) { return Ok{}; } - Result<> makeI16x8Const(Index, const std::array<uint16_t, 8>&) { + Result<> makeF32Const(Index, const std::vector<Annotation>&, float) { return Ok{}; } - Result<> makeI32x4Const(Index, const std::array<uint32_t, 4>&) { + Result<> makeF64Const(Index, const std::vector<Annotation>&, double) { return Ok{}; } - Result<> makeI64x2Const(Index, const std::array<uint64_t, 2>&) { + Result<> makeI8x16Const(Index, + const std::vector<Annotation>&, + const std::array<uint8_t, 16>&) { return Ok{}; } - Result<> makeF32x4Const(Index, const std::array<float, 4>&) { return Ok{}; } - Result<> makeF64x2Const(Index, const std::array<double, 2>&) { return Ok{}; } - Result<> makeLoad(Index, Type, bool, int, bool, MemoryIdxT*, MemargT) { + Result<> makeI16x8Const(Index, + const std::vector<Annotation>&, + const std::array<uint16_t, 8>&) { return Ok{}; } - Result<> makeStore(Index, Type, int, bool, MemoryIdxT*, MemargT) { + Result<> makeI32x4Const(Index, + const std::vector<Annotation>&, + const std::array<uint32_t, 4>&) { return Ok{}; } - Result<> makeAtomicRMW(Index, AtomicRMWOp, Type, int, MemoryIdxT*, MemargT) { + Result<> makeI64x2Const(Index, + const std::vector<Annotation>&, + const std::array<uint64_t, 2>&) { return Ok{}; } - Result<> makeAtomicCmpxchg(Index, Type, int, MemoryIdxT*, MemargT) { + Result<> makeF32x4Const(Index, + const std::vector<Annotation>&, + const std::array<float, 4>&) { return Ok{}; } - Result<> makeAtomicWait(Index, Type, MemoryIdxT*, MemargT) { return Ok{}; } - Result<> makeAtomicNotify(Index, MemoryIdxT*, MemargT) { return Ok{}; } - Result<> makeAtomicFence(Index) { return Ok{}; } - Result<> makeSIMDExtract(Index, SIMDExtractOp, uint8_t) { return Ok{}; } - Result<> makeSIMDReplace(Index, SIMDReplaceOp, uint8_t) { return Ok{}; } - Result<> makeSIMDShuffle(Index, const std::array<uint8_t, 16>&) { + Result<> makeF64x2Const(Index, + const std::vector<Annotation>&, + const std::array<double, 2>&) { return Ok{}; } - Result<> makeSIMDTernary(Index, SIMDTernaryOp) { return Ok{}; } - Result<> makeSIMDShift(Index, SIMDShiftOp) { return Ok{}; } - Result<> makeSIMDLoad(Index, SIMDLoadOp, MemoryIdxT*, MemargT) { + Result<> makeLoad(Index, + const std::vector<Annotation>&, + Type, + bool, + int, + bool, + MemoryIdxT*, + MemargT) { return Ok{}; } - Result<> makeSIMDLoadStoreLane( - Index, SIMDLoadStoreLaneOp, MemoryIdxT*, MemargT, uint8_t) { + Result<> makeStore(Index, + const std::vector<Annotation>&, + Type, + int, + bool, + MemoryIdxT*, + MemargT) { + return Ok{}; + } + Result<> makeAtomicRMW(Index, + const std::vector<Annotation>&, + AtomicRMWOp, + Type, + int, + MemoryIdxT*, + MemargT) { + return Ok{}; + } + Result<> makeAtomicCmpxchg( + Index, const std::vector<Annotation>&, Type, int, MemoryIdxT*, MemargT) { + return Ok{}; + } + Result<> makeAtomicWait( + Index, const std::vector<Annotation>&, Type, MemoryIdxT*, MemargT) { + return Ok{}; + } + Result<> makeAtomicNotify(Index, + const std::vector<Annotation>&, + MemoryIdxT*, + MemargT) { + return Ok{}; + } + Result<> makeAtomicFence(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> makeSIMDExtract(Index, + const std::vector<Annotation>&, + SIMDExtractOp, + uint8_t) { + return Ok{}; + } + Result<> makeSIMDReplace(Index, + const std::vector<Annotation>&, + SIMDReplaceOp, + uint8_t) { + return Ok{}; + } + Result<> makeSIMDShuffle(Index, + const std::vector<Annotation>&, + const std::array<uint8_t, 16>&) { + return Ok{}; + } + Result<> + makeSIMDTernary(Index, const std::vector<Annotation>&, SIMDTernaryOp) { + return Ok{}; + } + Result<> makeSIMDShift(Index, const std::vector<Annotation>&, SIMDShiftOp) { + return Ok{}; + } + Result<> makeSIMDLoad( + Index, const std::vector<Annotation>&, SIMDLoadOp, MemoryIdxT*, MemargT) { + return Ok{}; + } + Result<> makeSIMDLoadStoreLane(Index, + const std::vector<Annotation>&, + SIMDLoadStoreLaneOp, + MemoryIdxT*, + MemargT, + uint8_t) { + return Ok{}; + } + Result<> + makeMemoryInit(Index, const std::vector<Annotation>&, MemoryIdxT*, DataIdxT) { + return Ok{}; + } + Result<> makeDataDrop(Index, const std::vector<Annotation>&, DataIdxT) { return Ok{}; } - Result<> makeMemoryInit(Index, MemoryIdxT*, DataIdxT) { return Ok{}; } - Result<> makeDataDrop(Index, DataIdxT) { return Ok{}; } - Result<> makeMemoryCopy(Index, MemoryIdxT*, MemoryIdxT*) { return Ok{}; } - Result<> makeMemoryFill(Index, MemoryIdxT*) { return Ok{}; } - template<typename TypeT> Result<> makePop(Index, TypeT) { return Ok{}; } - Result<> makeCall(Index, FuncIdxT, bool) { return Ok{}; } + Result<> makeMemoryCopy(Index, + const std::vector<Annotation>&, + MemoryIdxT*, + MemoryIdxT*) { + return Ok{}; + } + Result<> makeMemoryFill(Index, const std::vector<Annotation>&, MemoryIdxT*) { + return Ok{}; + } + template<typename TypeT> + Result<> makePop(Index, const std::vector<Annotation>&, TypeT) { + return Ok{}; + } + Result<> makeCall(Index, const std::vector<Annotation>&, FuncIdxT, bool) { + return Ok{}; + } template<typename TypeUseT> - Result<> makeCallIndirect(Index, TableIdxT*, TypeUseT, bool) { + Result<> makeCallIndirect( + Index, const std::vector<Annotation>&, TableIdxT*, TypeUseT, bool) { + return Ok{}; + } + Result<> makeBreak(Index, const std::vector<Annotation>&, LabelIdxT, bool) { + return Ok{}; + } + Result<> makeSwitch(Index, + const std::vector<Annotation>&, + const std::vector<LabelIdxT>&, + LabelIdxT) { + return Ok{}; + } + Result<> makeReturn(Index, const std::vector<Annotation>&) { return Ok{}; } + template<typename HeapTypeT> + Result<> makeRefNull(Index, const std::vector<Annotation>&, HeapTypeT) { + return Ok{}; + } + Result<> makeRefIsNull(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeRefFunc(Index, const std::vector<Annotation>&, FuncIdxT) { + return Ok{}; + } + Result<> makeRefEq(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeTableGet(Index, const std::vector<Annotation>&, TableIdxT*) { + return Ok{}; + } + Result<> makeTableSet(Index, const std::vector<Annotation>&, TableIdxT*) { + return Ok{}; + } + Result<> makeTableSize(Index, const std::vector<Annotation>&, TableIdxT*) { + return Ok{}; + } + Result<> makeTableGrow(Index, const std::vector<Annotation>&, TableIdxT*) { + return Ok{}; + } + Result<> makeTableFill(Index, const std::vector<Annotation>&, TableIdxT*) { + return Ok{}; + } + Result<> + makeTableCopy(Index, const std::vector<Annotation>&, TableIdxT*, TableIdxT*) { + return Ok{}; + } + Result<> makeThrow(Index, const std::vector<Annotation>&, TagIdxT) { + return Ok{}; + } + Result<> makeRethrow(Index, const std::vector<Annotation>&, LabelIdxT) { + return Ok{}; + } + Result<> makeThrowRef(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeTupleMake(Index, const std::vector<Annotation>&, uint32_t) { + return Ok{}; + } + Result<> + makeTupleExtract(Index, const std::vector<Annotation>&, uint32_t, uint32_t) { + return Ok{}; + } + Result<> makeTupleDrop(Index, const std::vector<Annotation>&, uint32_t) { return Ok{}; } - Result<> makeBreak(Index, LabelIdxT, bool) { return Ok{}; } - Result<> makeSwitch(Index, const std::vector<LabelIdxT>&, LabelIdxT) { + template<typename HeapTypeT> + Result<> makeCallRef(Index, const std::vector<Annotation>&, HeapTypeT, bool) { + return Ok{}; + } + Result<> makeRefI31(Index, const std::vector<Annotation>&) { return Ok{}; } + Result<> makeI31Get(Index, const std::vector<Annotation>&, bool) { return Ok{}; } - Result<> makeReturn(Index) { return Ok{}; } - template<typename HeapTypeT> Result<> makeRefNull(Index, HeapTypeT) { + template<typename TypeT> + Result<> makeRefTest(Index, const std::vector<Annotation>&, TypeT) { return Ok{}; } - Result<> makeRefIsNull(Index) { return Ok{}; } - Result<> makeRefFunc(Index, FuncIdxT) { return Ok{}; } - Result<> makeRefEq(Index) { return Ok{}; } - Result<> makeTableGet(Index, TableIdxT*) { return Ok{}; } - Result<> makeTableSet(Index, TableIdxT*) { return Ok{}; } - Result<> makeTableSize(Index, TableIdxT*) { return Ok{}; } - Result<> makeTableGrow(Index, TableIdxT*) { return Ok{}; } - Result<> makeTableFill(Index, TableIdxT*) { return Ok{}; } - Result<> makeTableCopy(Index, TableIdxT*, TableIdxT*) { return Ok{}; } - Result<> makeThrow(Index, TagIdxT) { return Ok{}; } - Result<> makeRethrow(Index, LabelIdxT) { return Ok{}; } - Result<> makeThrowRef(Index) { return Ok{}; } - Result<> makeTupleMake(Index, uint32_t) { return Ok{}; } - Result<> makeTupleExtract(Index, uint32_t, uint32_t) { return Ok{}; } - Result<> makeTupleDrop(Index, uint32_t) { return Ok{}; } - template<typename HeapTypeT> Result<> makeCallRef(Index, HeapTypeT, bool) { + template<typename TypeT> + Result<> makeRefCast(Index, const std::vector<Annotation>&, TypeT) { return Ok{}; } - Result<> makeRefI31(Index) { return Ok{}; } - Result<> makeI31Get(Index, bool) { return Ok{}; } - template<typename TypeT> Result<> makeRefTest(Index, TypeT) { return Ok{}; } - template<typename TypeT> Result<> makeRefCast(Index, TypeT) { return Ok{}; } - Result<> makeBrOn(Index, LabelIdxT, BrOnOp) { return Ok{}; } + Result<> makeBrOn(Index, const std::vector<Annotation>&, LabelIdxT, BrOnOp) { + return Ok{}; + } template<typename TypeT> - Result<> makeBrOn(Index, LabelIdxT, BrOnOp, TypeT, TypeT) { + Result<> makeBrOn( + Index, const std::vector<Annotation>&, LabelIdxT, BrOnOp, TypeT, TypeT) { return Ok{}; } - template<typename HeapTypeT> Result<> makeStructNew(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> makeStructNew(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } - template<typename HeapTypeT> Result<> makeStructNewDefault(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> + makeStructNewDefault(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeStructGet(Index, HeapTypeT, FieldIdxT, bool) { + Result<> makeStructGet( + Index, const std::vector<Annotation>&, HeapTypeT, FieldIdxT, bool) { return Ok{}; } template<typename HeapTypeT> - Result<> makeStructSet(Index, HeapTypeT, FieldIdxT) { + Result<> + makeStructSet(Index, const std::vector<Annotation>&, HeapTypeT, FieldIdxT) { return Ok{}; } - template<typename HeapTypeT> Result<> makeArrayNew(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> makeArrayNew(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } - template<typename HeapTypeT> Result<> makeArrayNewDefault(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> + makeArrayNewDefault(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayNewData(Index, HeapTypeT, DataIdxT) { + Result<> + makeArrayNewData(Index, const std::vector<Annotation>&, HeapTypeT, DataIdxT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayNewElem(Index, HeapTypeT, ElemIdxT) { + Result<> + makeArrayNewElem(Index, const std::vector<Annotation>&, HeapTypeT, ElemIdxT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayNewFixed(Index, HeapTypeT, uint32_t) { + Result<> makeArrayNewFixed(Index, + const std::vector<Annotation>&, + HeapTypeT, + uint32_t) { return Ok{}; } - template<typename HeapTypeT> Result<> makeArrayGet(Index, HeapTypeT, bool) { + template<typename HeapTypeT> + Result<> + makeArrayGet(Index, const std::vector<Annotation>&, HeapTypeT, bool) { return Ok{}; } - template<typename HeapTypeT> Result<> makeArraySet(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> makeArraySet(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } - Result<> makeArrayLen(Index) { return Ok{}; } + Result<> makeArrayLen(Index, const std::vector<Annotation>&) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayCopy(Index, HeapTypeT, HeapTypeT) { + Result<> + makeArrayCopy(Index, const std::vector<Annotation>&, HeapTypeT, HeapTypeT) { return Ok{}; } - template<typename HeapTypeT> Result<> makeArrayFill(Index, HeapTypeT) { + template<typename HeapTypeT> + Result<> makeArrayFill(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayInitData(Index, HeapTypeT, DataIdxT) { + Result<> makeArrayInitData(Index, + const std::vector<Annotation>&, + HeapTypeT, + DataIdxT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeArrayInitElem(Index, HeapTypeT, ElemIdxT) { - return Ok{}; - } - Result<> makeRefAs(Index, RefAsOp) { return Ok{}; } - Result<> makeStringNew(Index, StringNewOp, bool, MemoryIdxT*) { return Ok{}; } - Result<> makeStringConst(Index, std::string_view) { return Ok{}; } - Result<> makeStringMeasure(Index, StringMeasureOp) { return Ok{}; } - Result<> makeStringEncode(Index, StringEncodeOp, MemoryIdxT*) { return Ok{}; } - Result<> makeStringConcat(Index) { return Ok{}; } - Result<> makeStringEq(Index, StringEqOp) { return Ok{}; } - Result<> makeStringAs(Index, StringAsOp) { return Ok{}; } - Result<> makeStringWTF8Advance(Index) { return Ok{}; } - Result<> makeStringWTF16Get(Index) { return Ok{}; } - Result<> makeStringIterNext(Index) { return Ok{}; } - Result<> makeStringIterMove(Index, StringIterMoveOp) { return Ok{}; } - Result<> makeStringSliceWTF(Index, StringSliceWTFOp) { return Ok{}; } - Result<> makeStringSliceIter(Index) { return Ok{}; } - template<typename HeapTypeT> Result<> makeContNew(Index, HeapTypeT) { + Result<> makeArrayInitElem(Index, + const std::vector<Annotation>&, + HeapTypeT, + ElemIdxT) { + return Ok{}; + } + Result<> makeRefAs(Index, const std::vector<Annotation>&, RefAsOp) { + return Ok{}; + } + Result<> makeStringNew( + Index, const std::vector<Annotation>&, StringNewOp, bool, MemoryIdxT*) { + return Ok{}; + } + Result<> + makeStringConst(Index, const std::vector<Annotation>&, std::string_view) { + return Ok{}; + } + Result<> + makeStringMeasure(Index, const std::vector<Annotation>&, StringMeasureOp) { + return Ok{}; + } + Result<> makeStringEncode(Index, + const std::vector<Annotation>&, + StringEncodeOp, + MemoryIdxT*) { + return Ok{}; + } + Result<> makeStringConcat(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> makeStringEq(Index, const std::vector<Annotation>&, StringEqOp) { + return Ok{}; + } + Result<> makeStringAs(Index, const std::vector<Annotation>&, StringAsOp) { + return Ok{}; + } + Result<> makeStringWTF8Advance(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> makeStringWTF16Get(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> makeStringIterNext(Index, const std::vector<Annotation>&) { + return Ok{}; + } + Result<> + makeStringIterMove(Index, const std::vector<Annotation>&, StringIterMoveOp) { + return Ok{}; + } + Result<> + makeStringSliceWTF(Index, const std::vector<Annotation>&, StringSliceWTFOp) { + return Ok{}; + } + Result<> makeStringSliceIter(Index, const std::vector<Annotation>&) { + return Ok{}; + } + template<typename HeapTypeT> + Result<> makeContNew(Index, const std::vector<Annotation>&, HeapTypeT) { return Ok{}; } template<typename HeapTypeT> - Result<> makeResume(Index, HeapTypeT, const TagLabelListT&) { + Result<> makeResume(Index, + const std::vector<Annotation>&, + HeapTypeT, + const TagLabelListT&) { return Ok{}; } }; @@ -1113,6 +1354,8 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { typeNames; const std::unordered_map<Index, Index>& implicitElemIndices; + std::unordered_map<std::string_view, Index> debugFileIndices; + // The index of the current module element. Index index = 0; @@ -1444,7 +1687,51 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return wasm.memories[0]->name; } - Result<> makeBlock(Index pos, std::optional<Name> label, HeapType type) { + void setSrcLoc(const Annotation& annotation) { + assert(annotation.kind == srcAnnotationKind); + Lexer lexer(annotation.contents); + auto contents = lexer.takeKeyword(); + if (!contents || !lexer.empty()) { + return; + } + + auto fileSize = contents->find(':'); + if (fileSize == contents->npos) { + return; + } + auto file = contents->substr(0, fileSize); + contents = contents->substr(fileSize + 1); + + auto lineSize = contents->find(':'); + if (fileSize == contents->npos) { + return; + } + auto line = Lexer(contents->substr(0, lineSize)).takeU32(); + if (!line) { + return; + } + contents = contents->substr(lineSize + 1); + + auto col = Lexer(*contents).takeU32(); + if (!col) { + return; + } + + // TODO: If we ever parallelize the parse, access to + // `wasm.debugInfoFileNames` will have to be protected by a lock. + auto [it, inserted] = + debugFileIndices.insert({file, debugFileIndices.size()}); + if (inserted) { + assert(wasm.debugInfoFileNames.size() == it->second); + wasm.debugInfoFileNames.push_back(std::string(file)); + } + irBuilder.setDebugLocation({it->second, *line, *col}); + } + + Result<> makeBlock(Index pos, + const std::vector<Annotation>& annotations, + std::optional<Name> label, + HeapType type) { // TODO: validate labels? // TODO: Move error on input types to here? return withLoc(pos, @@ -1452,7 +1739,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { type.getSignature().results)); } - Result<> makeIf(Index pos, std::optional<Name> label, HeapType type) { + Result<> makeIf(Index pos, + const std::vector<Annotation>& annotations, + std::optional<Name> label, + HeapType type) { // TODO: validate labels? // TODO: Move error on input types to here? return withLoc( @@ -1462,7 +1752,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { Result<> visitElse() { return withLoc(irBuilder.visitElse()); } - Result<> makeLoop(Index pos, std::optional<Name> label, HeapType type) { + Result<> makeLoop(Index pos, + const std::vector<Annotation>& annotations, + std::optional<Name> label, + HeapType type) { // TODO: validate labels? // TODO: Move error on input types to here? return withLoc( @@ -1470,7 +1763,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { irBuilder.makeLoop(label ? *label : Name{}, type.getSignature().results)); } - Result<> makeTry(Index pos, std::optional<Name> label, HeapType type) { + Result<> makeTry(Index pos, + const std::vector<Annotation>& annotations, + std::optional<Name> label, + HeapType type) { // TODO: validate labels? // TODO: Move error on input types to here? return withLoc( @@ -1479,6 +1775,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { } Result<> makeTryTable(Index pos, + const std::vector<Annotation>& annotations, std::optional<Name> label, HeapType type, const std::vector<CatchInfo>& info) { @@ -1512,21 +1809,29 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { Result<> visitEnd() { return withLoc(irBuilder.visitEnd()); } - Result<> makeUnreachable(Index pos) { + Result<> makeUnreachable(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeUnreachable()); } - Result<> makeNop(Index pos) { return withLoc(pos, irBuilder.makeNop()); } + Result<> makeNop(Index pos, const std::vector<Annotation>& annotations) { + return withLoc(pos, irBuilder.makeNop()); + } - Result<> makeBinary(Index pos, BinaryOp op) { + Result<> makeBinary(Index pos, + const std::vector<Annotation>& annotations, + BinaryOp op) { return withLoc(pos, irBuilder.makeBinary(op)); } - Result<> makeUnary(Index pos, UnaryOp op) { + Result<> + makeUnary(Index pos, const std::vector<Annotation>& annotations, UnaryOp op) { return withLoc(pos, irBuilder.makeUnary(op)); } - Result<> makeSelect(Index pos, std::vector<Type>* res) { + Result<> makeSelect(Index pos, + const std::vector<Annotation>& annotations, + std::vector<Type>* res) { if (res && res->size()) { if (res->size() > 1) { return in.err(pos, "select may not have more than one result type"); @@ -1536,58 +1841,83 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeSelect()); } - Result<> makeDrop(Index pos) { return withLoc(pos, irBuilder.makeDrop()); } + Result<> makeDrop(Index pos, const std::vector<Annotation>& annotations) { + return withLoc(pos, irBuilder.makeDrop()); + } - Result<> makeMemorySize(Index pos, Name* mem) { + Result<> makeMemorySize(Index pos, + const std::vector<Annotation>& annotations, + Name* mem) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeMemorySize(*m)); } - Result<> makeMemoryGrow(Index pos, Name* mem) { + Result<> makeMemoryGrow(Index pos, + const std::vector<Annotation>& annotations, + Name* mem) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeMemoryGrow(*m)); } - Result<> makeLocalGet(Index pos, Index local) { + Result<> makeLocalGet(Index pos, + const std::vector<Annotation>& annotations, + Index local) { return withLoc(pos, irBuilder.makeLocalGet(local)); } - Result<> makeLocalTee(Index pos, Index local) { + Result<> makeLocalTee(Index pos, + const std::vector<Annotation>& annotations, + Index local) { return withLoc(pos, irBuilder.makeLocalTee(local)); } - Result<> makeLocalSet(Index pos, Index local) { + Result<> makeLocalSet(Index pos, + const std::vector<Annotation>& annotations, + Index local) { return withLoc(pos, irBuilder.makeLocalSet(local)); } - Result<> makeGlobalGet(Index pos, Name global) { + Result<> makeGlobalGet(Index pos, + const std::vector<Annotation>& annotations, + Name global) { return withLoc(pos, irBuilder.makeGlobalGet(global)); } - Result<> makeGlobalSet(Index pos, Name global) { + Result<> makeGlobalSet(Index pos, + const std::vector<Annotation>& annotations, + Name global) { assert(wasm.getGlobalOrNull(global)); return withLoc(pos, irBuilder.makeGlobalSet(global)); } - Result<> makeI32Const(Index pos, uint32_t c) { + Result<> makeI32Const(Index pos, + const std::vector<Annotation>& annotations, + uint32_t c) { return withLoc(pos, irBuilder.makeConst(Literal(c))); } - Result<> makeI64Const(Index pos, uint64_t c) { + Result<> makeI64Const(Index pos, + const std::vector<Annotation>& annotations, + uint64_t c) { return withLoc(pos, irBuilder.makeConst(Literal(c))); } - Result<> makeF32Const(Index pos, float c) { + Result<> + makeF32Const(Index pos, const std::vector<Annotation>& annotations, float c) { return withLoc(pos, irBuilder.makeConst(Literal(c))); } - Result<> makeF64Const(Index pos, double c) { + Result<> makeF64Const(Index pos, + const std::vector<Annotation>& annotations, + double c) { return withLoc(pos, irBuilder.makeConst(Literal(c))); } - Result<> makeI8x16Const(Index pos, const std::array<uint8_t, 16>& vals) { + Result<> makeI8x16Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<uint8_t, 16>& vals) { std::array<Literal, 16> lanes; for (size_t i = 0; i < 16; ++i) { lanes[i] = Literal(uint32_t(vals[i])); @@ -1595,7 +1925,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeConst(Literal(lanes))); } - Result<> makeI16x8Const(Index pos, const std::array<uint16_t, 8>& vals) { + Result<> makeI16x8Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<uint16_t, 8>& vals) { std::array<Literal, 8> lanes; for (size_t i = 0; i < 8; ++i) { lanes[i] = Literal(uint32_t(vals[i])); @@ -1603,7 +1935,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeConst(Literal(lanes))); } - Result<> makeI32x4Const(Index pos, const std::array<uint32_t, 4>& vals) { + Result<> makeI32x4Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<uint32_t, 4>& vals) { std::array<Literal, 4> lanes; for (size_t i = 0; i < 4; ++i) { lanes[i] = Literal(vals[i]); @@ -1611,7 +1945,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeConst(Literal(lanes))); } - Result<> makeI64x2Const(Index pos, const std::array<uint64_t, 2>& vals) { + Result<> makeI64x2Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<uint64_t, 2>& vals) { std::array<Literal, 2> lanes; for (size_t i = 0; i < 2; ++i) { lanes[i] = Literal(vals[i]); @@ -1619,7 +1955,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeConst(Literal(lanes))); } - Result<> makeF32x4Const(Index pos, const std::array<float, 4>& vals) { + Result<> makeF32x4Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<float, 4>& vals) { std::array<Literal, 4> lanes; for (size_t i = 0; i < 4; ++i) { lanes[i] = Literal(vals[i]); @@ -1627,7 +1965,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeConst(Literal(lanes))); } - Result<> makeF64x2Const(Index pos, const std::array<double, 2>& vals) { + Result<> makeF64x2Const(Index pos, + const std::vector<Annotation>& annotations, + const std::array<double, 2>& vals) { std::array<Literal, 2> lanes; for (size_t i = 0; i < 2; ++i) { lanes[i] = Literal(vals[i]); @@ -1636,6 +1976,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { } Result<> makeLoad(Index pos, + const std::vector<Annotation>& annotations, Type type, bool signed_, int bytes, @@ -1653,8 +1994,13 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { bytes, signed_, memarg.offset, memarg.align, type, *m)); } - Result<> makeStore( - Index pos, Type type, int bytes, bool isAtomic, Name* mem, Memarg memarg) { + Result<> makeStore(Index pos, + const std::vector<Annotation>& annotations, + Type type, + int bytes, + bool isAtomic, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); if (isAtomic) { @@ -1665,67 +2011,104 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { pos, irBuilder.makeStore(bytes, memarg.offset, memarg.align, type, *m)); } - Result<> makeAtomicRMW( - Index pos, AtomicRMWOp op, Type type, int bytes, Name* mem, Memarg memarg) { + Result<> makeAtomicRMW(Index pos, + const std::vector<Annotation>& annotations, + AtomicRMWOp op, + Type type, + int bytes, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeAtomicRMW(op, bytes, memarg.offset, type, *m)); } - Result<> - makeAtomicCmpxchg(Index pos, Type type, int bytes, Name* mem, Memarg memarg) { + Result<> makeAtomicCmpxchg(Index pos, + const std::vector<Annotation>& annotations, + Type type, + int bytes, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeAtomicCmpxchg(bytes, memarg.offset, type, *m)); } - Result<> makeAtomicWait(Index pos, Type type, Name* mem, Memarg memarg) { + Result<> makeAtomicWait(Index pos, + const std::vector<Annotation>& annotations, + Type type, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeAtomicWait(type, memarg.offset, *m)); } - Result<> makeAtomicNotify(Index pos, Name* mem, Memarg memarg) { + Result<> makeAtomicNotify(Index pos, + const std::vector<Annotation>& annotations, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeAtomicNotify(memarg.offset, *m)); } - Result<> makeAtomicFence(Index pos) { + Result<> makeAtomicFence(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeAtomicFence()); } - Result<> makeSIMDExtract(Index pos, SIMDExtractOp op, uint8_t lane) { + Result<> makeSIMDExtract(Index pos, + const std::vector<Annotation>& annotations, + SIMDExtractOp op, + uint8_t lane) { return withLoc(pos, irBuilder.makeSIMDExtract(op, lane)); } - Result<> makeSIMDReplace(Index pos, SIMDReplaceOp op, uint8_t lane) { + Result<> makeSIMDReplace(Index pos, + const std::vector<Annotation>& annotations, + SIMDReplaceOp op, + uint8_t lane) { return withLoc(pos, irBuilder.makeSIMDReplace(op, lane)); } - Result<> makeSIMDShuffle(Index pos, const std::array<uint8_t, 16>& lanes) { + Result<> makeSIMDShuffle(Index pos, + const std::vector<Annotation>& annotations, + const std::array<uint8_t, 16>& lanes) { return withLoc(pos, irBuilder.makeSIMDShuffle(lanes)); } - Result<> makeSIMDTernary(Index pos, SIMDTernaryOp op) { + Result<> makeSIMDTernary(Index pos, + const std::vector<Annotation>& annotations, + SIMDTernaryOp op) { return withLoc(pos, irBuilder.makeSIMDTernary(op)); } - Result<> makeSIMDShift(Index pos, SIMDShiftOp op) { + Result<> makeSIMDShift(Index pos, + const std::vector<Annotation>& annotations, + SIMDShiftOp op) { return withLoc(pos, irBuilder.makeSIMDShift(op)); } - Result<> makeSIMDLoad(Index pos, SIMDLoadOp op, Name* mem, Memarg memarg) { + Result<> makeSIMDLoad(Index pos, + const std::vector<Annotation>& annotations, + SIMDLoadOp op, + Name* mem, + Memarg memarg) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeSIMDLoad(op, memarg.offset, memarg.align, *m)); } - Result<> makeSIMDLoadStoreLane( - Index pos, SIMDLoadStoreLaneOp op, Name* mem, Memarg memarg, uint8_t lane) { + Result<> makeSIMDLoadStoreLane(Index pos, + const std::vector<Annotation>& annotations, + SIMDLoadStoreLaneOp op, + Name* mem, + Memarg memarg, + uint8_t lane) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, @@ -1733,17 +2116,25 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { op, memarg.offset, memarg.align, lane, *m)); } - Result<> makeMemoryInit(Index pos, Name* mem, Name data) { + Result<> makeMemoryInit(Index pos, + const std::vector<Annotation>& annotations, + Name* mem, + Name data) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeMemoryInit(data, *m)); } - Result<> makeDataDrop(Index pos, Name data) { + Result<> makeDataDrop(Index pos, + const std::vector<Annotation>& annotations, + Name data) { return withLoc(pos, irBuilder.makeDataDrop(data)); } - Result<> makeMemoryCopy(Index pos, Name* destMem, Name* srcMem) { + Result<> makeMemoryCopy(Index pos, + const std::vector<Annotation>& annotations, + Name* destMem, + Name* srcMem) { auto destMemory = getMemory(pos, destMem); CHECK_ERR(destMemory); auto srcMemory = getMemory(pos, srcMem); @@ -1751,85 +2142,119 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeMemoryCopy(*destMemory, *srcMemory)); } - Result<> makeMemoryFill(Index pos, Name* mem) { + Result<> makeMemoryFill(Index pos, + const std::vector<Annotation>& annotations, + Name* mem) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeMemoryFill(*m)); } - Result<> makePop(Index pos, Type type) { + Result<> + makePop(Index pos, const std::vector<Annotation>& annotations, Type type) { return withLoc(pos, irBuilder.makePop(type)); } - Result<> makeCall(Index pos, Name func, bool isReturn) { + Result<> makeCall(Index pos, + const std::vector<Annotation>& annotations, + Name func, + bool isReturn) { return withLoc(pos, irBuilder.makeCall(func, isReturn)); } - Result<> - makeCallIndirect(Index pos, Name* table, HeapType type, bool isReturn) { + Result<> makeCallIndirect(Index pos, + const std::vector<Annotation>& annotations, + Name* table, + HeapType type, + bool isReturn) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeCallIndirect(*t, type, isReturn)); } - Result<> makeBreak(Index pos, Index label, bool isConditional) { + Result<> makeBreak(Index pos, + const std::vector<Annotation>& annotations, + Index label, + bool isConditional) { return withLoc(pos, irBuilder.makeBreak(label, isConditional)); } - Result<> - makeSwitch(Index pos, const std::vector<Index> labels, Index defaultLabel) { + Result<> makeSwitch(Index pos, + const std::vector<Annotation>& annotations, + const std::vector<Index> labels, + Index defaultLabel) { return withLoc(pos, irBuilder.makeSwitch(labels, defaultLabel)); } - Result<> makeReturn(Index pos) { + Result<> makeReturn(Index pos, const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeReturn()); } - Result<> makeRefNull(Index pos, HeapType type) { + Result<> makeRefNull(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeRefNull(type)); } - Result<> makeRefIsNull(Index pos) { + Result<> makeRefIsNull(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeRefIsNull()); } - Result<> makeRefFunc(Index pos, Name func) { + Result<> makeRefFunc(Index pos, + const std::vector<Annotation>& annotations, + Name func) { return withLoc(pos, irBuilder.makeRefFunc(func)); } - Result<> makeRefEq(Index pos) { return withLoc(pos, irBuilder.makeRefEq()); } + Result<> makeRefEq(Index pos, const std::vector<Annotation>& annotations) { + return withLoc(pos, irBuilder.makeRefEq()); + } - Result<> makeTableGet(Index pos, Name* table) { + Result<> makeTableGet(Index pos, + const std::vector<Annotation>& annotations, + Name* table) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeTableGet(*t)); } - Result<> makeTableSet(Index pos, Name* table) { + Result<> makeTableSet(Index pos, + const std::vector<Annotation>& annotations, + Name* table) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeTableSet(*t)); } - Result<> makeTableSize(Index pos, Name* table) { + Result<> makeTableSize(Index pos, + const std::vector<Annotation>& annotations, + Name* table) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeTableSize(*t)); } - Result<> makeTableGrow(Index pos, Name* table) { + Result<> makeTableGrow(Index pos, + const std::vector<Annotation>& annotations, + Name* table) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeTableGrow(*t)); } - Result<> makeTableFill(Index pos, Name* table) { + Result<> makeTableFill(Index pos, + const std::vector<Annotation>& annotations, + Name* table) { auto t = getTable(pos, table); CHECK_ERR(t); return withLoc(pos, irBuilder.makeTableFill(*t)); } - Result<> makeTableCopy(Index pos, Name* destTable, Name* srcTable) { + Result<> makeTableCopy(Index pos, + const std::vector<Annotation>& annotations, + Name* destTable, + Name* srcTable) { auto dest = getTable(pos, destTable); CHECK_ERR(dest); auto src = getTable(pos, srcTable); @@ -1837,51 +2262,71 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeTableCopy(*dest, *src)); } - Result<> makeThrow(Index pos, Name tag) { + Result<> + makeThrow(Index pos, const std::vector<Annotation>& annotations, Name tag) { return withLoc(pos, irBuilder.makeThrow(tag)); } - Result<> makeRethrow(Index pos, Index label) { + Result<> makeRethrow(Index pos, + const std::vector<Annotation>& annotations, + Index label) { return withLoc(pos, irBuilder.makeRethrow(label)); } - Result<> makeThrowRef(Index pos) { + Result<> makeThrowRef(Index pos, const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeThrowRef()); } - Result<> makeTupleMake(Index pos, uint32_t arity) { + Result<> makeTupleMake(Index pos, + const std::vector<Annotation>& annotations, + uint32_t arity) { return withLoc(pos, irBuilder.makeTupleMake(arity)); } - Result<> makeTupleExtract(Index pos, uint32_t arity, uint32_t index) { + Result<> makeTupleExtract(Index pos, + const std::vector<Annotation>& annotations, + uint32_t arity, + uint32_t index) { return withLoc(pos, irBuilder.makeTupleExtract(arity, index)); } - Result<> makeTupleDrop(Index pos, uint32_t arity) { + Result<> makeTupleDrop(Index pos, + const std::vector<Annotation>& annotations, + uint32_t arity) { return withLoc(pos, irBuilder.makeTupleDrop(arity)); } - Result<> makeCallRef(Index pos, HeapType type, bool isReturn) { + Result<> makeCallRef(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + bool isReturn) { return withLoc(pos, irBuilder.makeCallRef(type, isReturn)); } - Result<> makeRefI31(Index pos) { + Result<> makeRefI31(Index pos, const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeRefI31()); } - Result<> makeI31Get(Index pos, bool signed_) { + Result<> makeI31Get(Index pos, + const std::vector<Annotation>& annotations, + bool signed_) { return withLoc(pos, irBuilder.makeI31Get(signed_)); } - Result<> makeRefTest(Index pos, Type type) { + Result<> makeRefTest(Index pos, + const std::vector<Annotation>& annotations, + Type type) { return withLoc(pos, irBuilder.makeRefTest(type)); } - Result<> makeRefCast(Index pos, Type type) { + Result<> makeRefCast(Index pos, + const std::vector<Annotation>& annotations, + Type type) { return withLoc(pos, irBuilder.makeRefCast(type)); } Result<> makeBrOn(Index pos, + const std::vector<Annotation>& annotations, Index label, BrOnOp op, Type in = Type::none, @@ -1889,136 +2334,205 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> { return withLoc(pos, irBuilder.makeBrOn(label, op, in, out)); } - Result<> makeStructNew(Index pos, HeapType type) { + Result<> makeStructNew(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeStructNew(type)); } - Result<> makeStructNewDefault(Index pos, HeapType type) { + Result<> makeStructNewDefault(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeStructNewDefault(type)); } - Result<> makeStructGet(Index pos, HeapType type, Index field, bool signed_) { + Result<> makeStructGet(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Index field, + bool signed_) { return withLoc(pos, irBuilder.makeStructGet(type, field, signed_)); } - Result<> makeStructSet(Index pos, HeapType type, Index field) { + Result<> makeStructSet(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Index field) { return withLoc(pos, irBuilder.makeStructSet(type, field)); } - Result<> makeArrayNew(Index pos, HeapType type) { + Result<> makeArrayNew(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeArrayNew(type)); } - Result<> makeArrayNewDefault(Index pos, HeapType type) { + Result<> makeArrayNewDefault(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeArrayNewDefault(type)); } - Result<> makeArrayNewData(Index pos, HeapType type, Name data) { + Result<> makeArrayNewData(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Name data) { return withLoc(pos, irBuilder.makeArrayNewData(type, data)); } - Result<> makeArrayNewElem(Index pos, HeapType type, Name elem) { + Result<> makeArrayNewElem(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Name elem) { return withLoc(pos, irBuilder.makeArrayNewElem(type, elem)); } - Result<> makeArrayNewFixed(Index pos, HeapType type, uint32_t arity) { + Result<> makeArrayNewFixed(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + uint32_t arity) { return withLoc(pos, irBuilder.makeArrayNewFixed(type, arity)); } - Result<> makeArrayGet(Index pos, HeapType type, bool signed_) { + Result<> makeArrayGet(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + bool signed_) { return withLoc(pos, irBuilder.makeArrayGet(type, signed_)); } - Result<> makeArraySet(Index pos, HeapType type) { + Result<> makeArraySet(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeArraySet(type)); } - Result<> makeArrayLen(Index pos) { + Result<> makeArrayLen(Index pos, const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeArrayLen()); } - Result<> makeArrayCopy(Index pos, HeapType destType, HeapType srcType) { + Result<> makeArrayCopy(Index pos, + const std::vector<Annotation>& annotations, + HeapType destType, + HeapType srcType) { return withLoc(pos, irBuilder.makeArrayCopy(destType, srcType)); } - Result<> makeArrayFill(Index pos, HeapType type) { + Result<> makeArrayFill(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeArrayFill(type)); } - Result<> makeArrayInitData(Index pos, HeapType type, Name data) { + Result<> makeArrayInitData(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Name data) { return withLoc(pos, irBuilder.makeArrayInitData(type, data)); } - Result<> makeArrayInitElem(Index pos, HeapType type, Name elem) { + Result<> makeArrayInitElem(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + Name elem) { return withLoc(pos, irBuilder.makeArrayInitElem(type, elem)); } - Result<> makeRefAs(Index pos, RefAsOp op) { + Result<> + makeRefAs(Index pos, const std::vector<Annotation>& annotations, RefAsOp op) { return withLoc(pos, irBuilder.makeRefAs(op)); } - Result<> makeStringNew(Index pos, StringNewOp op, bool try_, Name* mem) { + Result<> makeStringNew(Index pos, + const std::vector<Annotation>& annotations, + StringNewOp op, + bool try_, + Name* mem) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeStringNew(op, try_, *m)); } - Result<> makeStringConst(Index pos, std::string_view str) { + Result<> makeStringConst(Index pos, + const std::vector<Annotation>& annotations, + std::string_view str) { return withLoc(pos, irBuilder.makeStringConst(Name(str))); } - Result<> makeStringMeasure(Index pos, StringMeasureOp op) { + Result<> makeStringMeasure(Index pos, + const std::vector<Annotation>& annotations, + StringMeasureOp op) { return withLoc(pos, irBuilder.makeStringMeasure(op)); } - Result<> makeStringEncode(Index pos, StringEncodeOp op, Name* mem) { + Result<> makeStringEncode(Index pos, + const std::vector<Annotation>& annotations, + StringEncodeOp op, + Name* mem) { auto m = getMemory(pos, mem); CHECK_ERR(m); return withLoc(pos, irBuilder.makeStringEncode(op, *m)); } - Result<> makeStringConcat(Index pos) { + Result<> makeStringConcat(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeStringConcat()); } - Result<> makeStringEq(Index pos, StringEqOp op) { + Result<> makeStringEq(Index pos, + const std::vector<Annotation>& annotations, + StringEqOp op) { return withLoc(pos, irBuilder.makeStringEq(op)); } - Result<> makeStringAs(Index pos, StringAsOp op) { + Result<> makeStringAs(Index pos, + const std::vector<Annotation>& annotations, + StringAsOp op) { return withLoc(pos, irBuilder.makeStringAs(op)); } - Result<> makeStringWTF8Advance(Index pos) { + Result<> makeStringWTF8Advance(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeStringWTF8Advance()); } - Result<> makeStringWTF16Get(Index pos) { + Result<> makeStringWTF16Get(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeStringWTF16Get()); } - Result<> makeStringIterNext(Index pos) { + Result<> makeStringIterNext(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeStringIterNext()); } - Result<> makeStringIterMove(Index pos, StringIterMoveOp op) { + Result<> makeStringIterMove(Index pos, + const std::vector<Annotation>& annotations, + StringIterMoveOp op) { return withLoc(pos, irBuilder.makeStringIterMove(op)); } - Result<> makeStringSliceWTF(Index pos, StringSliceWTFOp op) { + Result<> makeStringSliceWTF(Index pos, + const std::vector<Annotation>& annotations, + StringSliceWTFOp op) { return withLoc(pos, irBuilder.makeStringSliceWTF(op)); } - Result<> makeStringSliceIter(Index pos) { + Result<> makeStringSliceIter(Index pos, + const std::vector<Annotation>& annotations) { return withLoc(pos, irBuilder.makeStringSliceIter()); } - Result<> makeContNew(Index pos, HeapType type) { + Result<> makeContNew(Index pos, + const std::vector<Annotation>& annotations, + HeapType type) { return withLoc(pos, irBuilder.makeContNew(type)); } - Result<> - makeResume(Index pos, HeapType type, const TagLabelListT& tagLabels) { + Result<> makeResume(Index pos, + const std::vector<Annotation>& annotations, + HeapType type, + const TagLabelListT& tagLabels) { std::vector<Name> tags; std::vector<Index> labels; tags.reserve(tagLabels.size()); |