From f6f898b6b6f85b5e2c4f5bc0c61b8465e72dc35e Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Fri, 15 Nov 2024 16:58:48 -0500 Subject: [PATCH] [NFC] Remove redundant [[nodiscard]] attributes (#7084) Now that Result and MaybeResult are annotated [[nodiscard]] at the type level, individual functions and methods that return these types do not need to be annotated [[nodiscard]] themselves. Remove the newly redundant annotations. --- src/wasm-ir-builder.h | 288 +++++++++++++++++------------------ src/wasm/wasm-ir-builder.cpp | 2 +- 2 files changed, 140 insertions(+), 150 deletions(-) diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h index 0210c55e50b..d6e45314933 100644 --- a/src/wasm-ir-builder.h +++ b/src/wasm-ir-builder.h @@ -45,11 +45,11 @@ class IRBuilder : public UnifiedExpressionVisitor> { // Get the valid Binaryen IR expression representing the sequence of visited // instructions. The IRBuilder is reset and can be used with a fresh sequence // of instructions after this is called. - [[nodiscard]] Result build(); + Result build(); // Call visit() on an existing Expression with its non-child fields // initialized to initialize the child fields and refinalize it. - [[nodiscard]] Result<> visit(Expression*); + Result<> visit(Expression*); // Like visit, but pushes the expression onto the stack as-is without popping // any children or refinalization. @@ -66,27 +66,26 @@ class IRBuilder : public UnifiedExpressionVisitor> { // Handle the boundaries of control flow structures. Users may choose to use // the corresponding `makeXYZ` function below instead of `visitXYZStart`, but // either way must call `visitEnd` and friends at the appropriate times. - [[nodiscard]] Result<> visitFunctionStart(Function* func); - [[nodiscard]] Result<> visitBlockStart(Block* block); - [[nodiscard]] Result<> visitIfStart(If* iff, Name label = {}); - [[nodiscard]] Result<> visitElse(); - [[nodiscard]] Result<> visitLoopStart(Loop* iff); - [[nodiscard]] Result<> visitTryStart(Try* tryy, Name label = {}); - [[nodiscard]] Result<> visitCatch(Name tag); - [[nodiscard]] Result<> visitCatchAll(); - [[nodiscard]] Result<> visitDelegate(Index label); - [[nodiscard]] Result<> visitTryTableStart(TryTable* trytable, - Name label = {}); - [[nodiscard]] Result<> visitEnd(); + Result<> visitFunctionStart(Function* func); + Result<> visitBlockStart(Block* block); + Result<> visitIfStart(If* iff, Name label = {}); + Result<> visitElse(); + Result<> visitLoopStart(Loop* iff); + Result<> visitTryStart(Try* tryy, Name label = {}); + Result<> visitCatch(Name tag); + Result<> visitCatchAll(); + Result<> visitDelegate(Index label); + Result<> visitTryTableStart(TryTable* trytable, Name label = {}); + Result<> visitEnd(); // Used to visit break nodes when traversing a single block without its // context. The type indicates how many values the break carries to its // destination. - [[nodiscard]] Result<> visitBreakWithType(Break*, Type); + Result<> visitBreakWithType(Break*, Type); // Used to visit switch nodes when traversing a single block without its // context. The type indicates how many values the switch carries to its // destination. - [[nodiscard]] Result<> visitSwitchWithType(Switch*, Type); + Result<> visitSwitchWithType(Switch*, Type); // Binaryen IR uses names to refer to branch targets, but in general there may // be branches to constructs that do not yet have names, so in IRBuilder we @@ -95,145 +94,138 @@ class IRBuilder : public UnifiedExpressionVisitor> { // // Labels in delegates need special handling because the indexing needs to be // relative to the try's enclosing scope rather than the try itself. - [[nodiscard]] Result getLabelIndex(Name label, - bool inDelegate = false); + Result getLabelIndex(Name label, bool inDelegate = false); // Instead of calling visit, call makeXYZ to have the IRBuilder allocate the // nodes. This is generally safer than calling `visit` because the function // signatures ensure that there are no missing fields. - [[nodiscard]] Result<> makeNop(); - [[nodiscard]] Result<> makeBlock(Name label, Type type); - [[nodiscard]] Result<> makeIf(Name label, Type type); - [[nodiscard]] Result<> makeLoop(Name label, Type type); - [[nodiscard]] Result<> makeBreak(Index label, bool isConditional); - [[nodiscard]] Result<> makeSwitch(const std::vector& labels, - Index defaultLabel); + Result<> makeNop(); + Result<> makeBlock(Name label, Type type); + Result<> makeIf(Name label, Type type); + Result<> makeLoop(Name label, Type type); + Result<> makeBreak(Index label, bool isConditional); + Result<> makeSwitch(const std::vector& labels, Index defaultLabel); // Unlike Builder::makeCall, this assumes the function already exists. - [[nodiscard]] Result<> makeCall(Name func, bool isReturn); - [[nodiscard]] Result<> - makeCallIndirect(Name table, HeapType type, bool isReturn); - [[nodiscard]] Result<> makeLocalGet(Index local); - [[nodiscard]] Result<> makeLocalSet(Index local); - [[nodiscard]] Result<> makeLocalTee(Index local); - [[nodiscard]] Result<> makeGlobalGet(Name global); - [[nodiscard]] Result<> makeGlobalSet(Name global); - [[nodiscard]] Result<> makeLoad(unsigned bytes, - bool signed_, - Address offset, - unsigned align, - Type type, - Name mem); - [[nodiscard]] Result<> makeStore( + Result<> makeCall(Name func, bool isReturn); + Result<> makeCallIndirect(Name table, HeapType type, bool isReturn); + Result<> makeLocalGet(Index local); + Result<> makeLocalSet(Index local); + Result<> makeLocalTee(Index local); + Result<> makeGlobalGet(Name global); + Result<> makeGlobalSet(Name global); + Result<> makeLoad(unsigned bytes, + bool signed_, + Address offset, + unsigned align, + Type type, + Name mem); + Result<> makeStore( unsigned bytes, Address offset, unsigned align, Type type, Name mem); - [[nodiscard]] Result<> - makeAtomicLoad(unsigned bytes, Address offset, Type type, Name mem); - [[nodiscard]] Result<> - makeAtomicStore(unsigned bytes, Address offset, Type type, Name mem); - [[nodiscard]] Result<> makeAtomicRMW( + Result<> makeAtomicLoad(unsigned bytes, Address offset, Type type, Name mem); + Result<> makeAtomicStore(unsigned bytes, Address offset, Type type, Name mem); + Result<> makeAtomicRMW( AtomicRMWOp op, unsigned bytes, Address offset, Type type, Name mem); - [[nodiscard]] Result<> + Result<> makeAtomicCmpxchg(unsigned bytes, Address offset, Type type, Name mem); - [[nodiscard]] Result<> makeAtomicWait(Type type, Address offset, Name mem); - [[nodiscard]] Result<> makeAtomicNotify(Address offset, Name mem); - [[nodiscard]] Result<> makeAtomicFence(); - [[nodiscard]] Result<> makeSIMDExtract(SIMDExtractOp op, uint8_t lane); - [[nodiscard]] Result<> makeSIMDReplace(SIMDReplaceOp op, uint8_t lane); - [[nodiscard]] Result<> makeSIMDShuffle(const std::array& lanes); - [[nodiscard]] Result<> makeSIMDTernary(SIMDTernaryOp op); - [[nodiscard]] Result<> makeSIMDShift(SIMDShiftOp op); - [[nodiscard]] Result<> + Result<> makeAtomicWait(Type type, Address offset, Name mem); + Result<> makeAtomicNotify(Address offset, Name mem); + Result<> makeAtomicFence(); + Result<> makeSIMDExtract(SIMDExtractOp op, uint8_t lane); + Result<> makeSIMDReplace(SIMDReplaceOp op, uint8_t lane); + Result<> makeSIMDShuffle(const std::array& lanes); + Result<> makeSIMDTernary(SIMDTernaryOp op); + Result<> makeSIMDShift(SIMDShiftOp op); + Result<> makeSIMDLoad(SIMDLoadOp op, Address offset, unsigned align, Name mem); - [[nodiscard]] Result<> makeSIMDLoadStoreLane(SIMDLoadStoreLaneOp op, - Address offset, - unsigned align, - uint8_t lane, - Name mem); - [[nodiscard]] Result<> makeMemoryInit(Name data, Name mem); - [[nodiscard]] Result<> makeDataDrop(Name data); - [[nodiscard]] Result<> makeMemoryCopy(Name destMem, Name srcMem); - [[nodiscard]] Result<> makeMemoryFill(Name mem); - [[nodiscard]] Result<> makeConst(Literal val); - [[nodiscard]] Result<> makeUnary(UnaryOp op); - [[nodiscard]] Result<> makeBinary(BinaryOp op); - [[nodiscard]] Result<> makeSelect(std::optional type = std::nullopt); - [[nodiscard]] Result<> makeDrop(); - [[nodiscard]] Result<> makeReturn(); - [[nodiscard]] Result<> makeMemorySize(Name mem); - [[nodiscard]] Result<> makeMemoryGrow(Name mem); - [[nodiscard]] Result<> makeUnreachable(); - [[nodiscard]] Result<> makePop(Type type); - [[nodiscard]] Result<> makeRefNull(HeapType type); - [[nodiscard]] Result<> makeRefIsNull(); - [[nodiscard]] Result<> makeRefFunc(Name func); - [[nodiscard]] Result<> makeRefEq(); - [[nodiscard]] Result<> makeTableGet(Name table); - [[nodiscard]] Result<> makeTableSet(Name table); - [[nodiscard]] Result<> makeTableSize(Name table); - [[nodiscard]] Result<> makeTableGrow(Name table); - [[nodiscard]] Result<> makeTableFill(Name table); - [[nodiscard]] Result<> makeTableCopy(Name destTable, Name srcTable); - [[nodiscard]] Result<> makeTableInit(Name elem, Name table); - [[nodiscard]] Result<> makeTry(Name label, Type type); - [[nodiscard]] Result<> makeTryTable(Name label, - Type type, - const std::vector& tags, - const std::vector& labels, - const std::vector& isRefs); - [[nodiscard]] Result<> makeThrow(Name tag); - [[nodiscard]] Result<> makeRethrow(Index label); - [[nodiscard]] Result<> makeThrowRef(); - [[nodiscard]] Result<> makeTupleMake(uint32_t arity); - [[nodiscard]] Result<> makeTupleExtract(uint32_t arity, uint32_t index); - [[nodiscard]] Result<> makeTupleDrop(uint32_t arity); - [[nodiscard]] Result<> makeRefI31(Shareability share); - [[nodiscard]] Result<> makeI31Get(bool signed_); - [[nodiscard]] Result<> makeCallRef(HeapType type, bool isReturn); - [[nodiscard]] Result<> makeRefTest(Type type); - [[nodiscard]] Result<> makeRefCast(Type type); - [[nodiscard]] Result<> + Result<> makeSIMDLoadStoreLane(SIMDLoadStoreLaneOp op, + Address offset, + unsigned align, + uint8_t lane, + Name mem); + Result<> makeMemoryInit(Name data, Name mem); + Result<> makeDataDrop(Name data); + Result<> makeMemoryCopy(Name destMem, Name srcMem); + Result<> makeMemoryFill(Name mem); + Result<> makeConst(Literal val); + Result<> makeUnary(UnaryOp op); + Result<> makeBinary(BinaryOp op); + Result<> makeSelect(std::optional type = std::nullopt); + Result<> makeDrop(); + Result<> makeReturn(); + Result<> makeMemorySize(Name mem); + Result<> makeMemoryGrow(Name mem); + Result<> makeUnreachable(); + Result<> makePop(Type type); + Result<> makeRefNull(HeapType type); + Result<> makeRefIsNull(); + Result<> makeRefFunc(Name func); + Result<> makeRefEq(); + Result<> makeTableGet(Name table); + Result<> makeTableSet(Name table); + Result<> makeTableSize(Name table); + Result<> makeTableGrow(Name table); + Result<> makeTableFill(Name table); + Result<> makeTableCopy(Name destTable, Name srcTable); + Result<> makeTableInit(Name elem, Name table); + Result<> makeTry(Name label, Type type); + Result<> makeTryTable(Name label, + Type type, + const std::vector& tags, + const std::vector& labels, + const std::vector& isRefs); + Result<> makeThrow(Name tag); + Result<> makeRethrow(Index label); + Result<> makeThrowRef(); + Result<> makeTupleMake(uint32_t arity); + Result<> makeTupleExtract(uint32_t arity, uint32_t index); + Result<> makeTupleDrop(uint32_t arity); + Result<> makeRefI31(Shareability share); + Result<> makeI31Get(bool signed_); + Result<> makeCallRef(HeapType type, bool isReturn); + Result<> makeRefTest(Type type); + Result<> makeRefCast(Type type); + Result<> makeBrOn(Index label, BrOnOp op, Type in = Type::none, Type out = Type::none); - [[nodiscard]] Result<> makeStructNew(HeapType type); - [[nodiscard]] Result<> makeStructNewDefault(HeapType type); - [[nodiscard]] Result<> - makeStructGet(HeapType type, Index field, bool signed_); - [[nodiscard]] Result<> makeStructSet(HeapType type, Index field); - [[nodiscard]] Result<> makeArrayNew(HeapType type); - [[nodiscard]] Result<> makeArrayNewDefault(HeapType type); - [[nodiscard]] Result<> makeArrayNewData(HeapType type, Name data); - [[nodiscard]] Result<> makeArrayNewElem(HeapType type, Name elem); - [[nodiscard]] Result<> makeArrayNewFixed(HeapType type, uint32_t arity); - [[nodiscard]] Result<> makeArrayGet(HeapType type, bool signed_); - [[nodiscard]] Result<> makeArraySet(HeapType type); - [[nodiscard]] Result<> makeArrayLen(); - [[nodiscard]] Result<> makeArrayCopy(HeapType destType, HeapType srcType); - [[nodiscard]] Result<> makeArrayFill(HeapType type); - [[nodiscard]] Result<> makeArrayInitData(HeapType type, Name data); - [[nodiscard]] Result<> makeArrayInitElem(HeapType type, Name elem); - [[nodiscard]] Result<> makeRefAs(RefAsOp op); - [[nodiscard]] Result<> makeStringNew(StringNewOp op); - [[nodiscard]] Result<> makeStringConst(Name string); - [[nodiscard]] Result<> makeStringMeasure(StringMeasureOp op); - [[nodiscard]] Result<> makeStringEncode(StringEncodeOp op); - [[nodiscard]] Result<> makeStringConcat(); - [[nodiscard]] Result<> makeStringEq(StringEqOp op); - [[nodiscard]] Result<> makeStringWTF8Advance(); - [[nodiscard]] Result<> makeStringWTF16Get(); - [[nodiscard]] Result<> makeStringIterNext(); - [[nodiscard]] Result<> makeStringSliceWTF(); - [[nodiscard]] Result<> makeContBind(HeapType contTypeBefore, - HeapType contTypeAfter); - [[nodiscard]] Result<> makeContNew(HeapType ct); - [[nodiscard]] Result<> makeResume(HeapType ct, - const std::vector& tags, - const std::vector& labels); - [[nodiscard]] Result<> makeSuspend(Name tag); + Result<> makeStructNew(HeapType type); + Result<> makeStructNewDefault(HeapType type); + Result<> makeStructGet(HeapType type, Index field, bool signed_); + Result<> makeStructSet(HeapType type, Index field); + Result<> makeArrayNew(HeapType type); + Result<> makeArrayNewDefault(HeapType type); + Result<> makeArrayNewData(HeapType type, Name data); + Result<> makeArrayNewElem(HeapType type, Name elem); + Result<> makeArrayNewFixed(HeapType type, uint32_t arity); + Result<> makeArrayGet(HeapType type, bool signed_); + Result<> makeArraySet(HeapType type); + Result<> makeArrayLen(); + Result<> makeArrayCopy(HeapType destType, HeapType srcType); + Result<> makeArrayFill(HeapType type); + Result<> makeArrayInitData(HeapType type, Name data); + Result<> makeArrayInitElem(HeapType type, Name elem); + Result<> makeRefAs(RefAsOp op); + Result<> makeStringNew(StringNewOp op); + Result<> makeStringConst(Name string); + Result<> makeStringMeasure(StringMeasureOp op); + Result<> makeStringEncode(StringEncodeOp op); + Result<> makeStringConcat(); + Result<> makeStringEq(StringEqOp op); + Result<> makeStringWTF8Advance(); + Result<> makeStringWTF16Get(); + Result<> makeStringIterNext(); + Result<> makeStringSliceWTF(); + Result<> makeContBind(HeapType contTypeBefore, HeapType contTypeAfter); + Result<> makeContNew(HeapType ct); + Result<> makeResume(HeapType ct, + const std::vector& tags, + const std::vector& labels); + Result<> makeSuspend(Name tag); // Private functions that must be public for technical reasons. - [[nodiscard]] Result<> visitExpression(Expression*); + Result<> visitExpression(Expression*); // Do not push pops onto the stack since we generate our own pops as necessary // when visiting the beginnings of try blocks. - [[nodiscard]] Result<> visitPop(Pop*) { return Ok{}; } + Result<> visitPop(Pop*) { return Ok{}; } private: Module& wasm; @@ -562,12 +554,11 @@ class IRBuilder : public UnifiedExpressionVisitor> { // `block`, but otherwise we will have to allocate a new block. Result finishScope(Block* block = nullptr); - [[nodiscard]] Result getLabelName(Index label, - bool forDelegate = false); - [[nodiscard]] Result getDelegateLabelName(Index label) { + Result getLabelName(Index label, bool forDelegate = false); + Result getDelegateLabelName(Index label) { return getLabelName(label, true); } - [[nodiscard]] Result addScratchLocal(Type); + Result addScratchLocal(Type); struct HoistedVal { // The index in the stack of the original value-producing expression. @@ -578,7 +569,7 @@ class IRBuilder : public UnifiedExpressionVisitor> { // Find the last value-producing expression, if any, and hoist its value to // the top of the stack using a scratch local if necessary. - [[nodiscard]] MaybeResult hoistLastValue(); + MaybeResult hoistLastValue(); // Transform the stack as necessary such that the original producer of the // hoisted value will be popped along with the final expression that produces // the value, if they are different. May only be called directly after @@ -586,11 +577,10 @@ class IRBuilder : public UnifiedExpressionVisitor> { // consume, so if the hoisted value has `sizeHint` elements, it is left intact // even if it is a tuple. Otherwise, hoisted tuple values will be broken into // pieces. - [[nodiscard]] Result<> packageHoistedValue(const HoistedVal&, - size_t sizeHint = 1); + Result<> packageHoistedValue(const HoistedVal&, size_t sizeHint = 1); - [[nodiscard]] Result getLabelType(Index label); - [[nodiscard]] Result getLabelType(Name labelName); + Result getLabelType(Index label); + Result getLabelType(Name labelName); void dump(); }; diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp index 398db68ff4f..0d46156be28 100644 --- a/src/wasm/wasm-ir-builder.cpp +++ b/src/wasm/wasm-ir-builder.cpp @@ -366,7 +366,7 @@ struct IRBuilder::ChildPopper ChildPopper(IRBuilder& builder) : builder(builder) {} private: - [[nodiscard]] Result<> popConstrainedChildren(std::vector& children) { + Result<> popConstrainedChildren(std::vector& children) { auto& scope = builder.getScope(); // Two-part indices into the stack of available expressions and the vector