From 1afef8442f597f88339b1aa5a6e6d8a6e0828e5b Mon Sep 17 00:00:00 2001 From: Kewen Meng Date: Mon, 24 Nov 2025 18:00:48 -0800 Subject: [PATCH] Revert "[MC] Use a variant to hold MCCFIInstruction state (NFC) (#164720)" This reverts commit fd94b410ef60ca0a0494c2164d7897b698315443. --- llvm/include/llvm/MC/MCDwarf.h | 137 ++++++++++++++++++--------------- 1 file changed, 77 insertions(+), 60 deletions(-) diff --git a/llvm/include/llvm/MC/MCDwarf.h b/llvm/include/llvm/MC/MCDwarf.h index 640d2eeb68d61..9944a9a92ab1f 100644 --- a/llvm/include/llvm/MC/MCDwarf.h +++ b/llvm/include/llvm/MC/MCDwarf.h @@ -29,7 +29,6 @@ #include #include #include -#include #include namespace llvm { @@ -532,47 +531,67 @@ class MCCFIInstruction { OpValOffset, }; - // Held in ExtraFields for most common OpTypes, exceptions follow. - struct CommonFields { - unsigned Register = std::numeric_limits::max(); - int64_t Offset = 0; - unsigned Register2 = std::numeric_limits::max(); - unsigned AddressSpace = 0; - }; - // Held in ExtraFields when OpEscape. - struct EscapeFields { - std::vector Values; - std::string Comment; - }; - // Held in ExtraFields when OpLabel. - struct LabelFields { - MCSymbol *CfiLabel = nullptr; - }; - private: MCSymbol *Label; - std::variant ExtraFields; + union { + struct { + unsigned Register; + int64_t Offset; + } RI; + struct { + unsigned Register; + int64_t Offset; + unsigned AddressSpace; + } RIA; + struct { + unsigned Register; + unsigned Register2; + } RR; + MCSymbol *CfiLabel; + } U; OpType Operation; SMLoc Loc; + std::vector Values; + std::string Comment; - template - MCCFIInstruction(OpType Op, MCSymbol *L, FieldsType &&EF, SMLoc Loc) - : Label(L), ExtraFields(std::forward(EF)), Operation(Op), - Loc(Loc) {} + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, SMLoc Loc, + StringRef V = "", StringRef Comment = "") + : Label(L), Operation(Op), Loc(Loc), Values(V.begin(), V.end()), + Comment(Comment) { + assert(Op != OpRegister && Op != OpLLVMDefAspaceCfa); + U.RI = {R, O}; + } + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2, SMLoc Loc) + : Label(L), Operation(Op), Loc(Loc) { + assert(Op == OpRegister); + U.RR = {R1, R2}; + } + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, unsigned AS, + SMLoc Loc) + : Label(L), Operation(Op), Loc(Loc) { + assert(Op == OpLLVMDefAspaceCfa); + U.RIA = {R, O, AS}; + } + + MCCFIInstruction(OpType Op, MCSymbol *L, MCSymbol *CfiLabel, SMLoc Loc) + : Label(L), Operation(Op), Loc(Loc) { + assert(Op == OpLabel); + U.CfiLabel = CfiLabel; + } public: /// .cfi_def_cfa defines a rule for computing CFA as: take address from /// Register and add Offset to it. static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc = {}) { - return {OpDefCfa, L, CommonFields{Register, Offset}, Loc}; + return MCCFIInstruction(OpDefCfa, L, Register, Offset, Loc); } /// .cfi_def_cfa_register modifies a rule for computing CFA. From now /// on Register will be used instead of the old one. Offset remains the same. static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register, SMLoc Loc = {}) { - return {OpDefCfaRegister, L, CommonFields{Register}, Loc}; + return MCCFIInstruction(OpDefCfaRegister, L, Register, INT64_C(0), Loc); } /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register @@ -580,7 +599,7 @@ class MCCFIInstruction { /// that will be added to a defined register to the compute CFA address. static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset, SMLoc Loc = {}) { - return {OpDefCfaOffset, L, CommonFields{0, Offset}, Loc}; + return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, Loc); } /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but @@ -588,7 +607,7 @@ class MCCFIInstruction { /// offset. static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int64_t Adjustment, SMLoc Loc = {}) { - return {OpAdjustCfaOffset, L, CommonFields{0, Adjustment}, Loc}; + return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, Loc); } // FIXME: Update the remaining docs to use the new proposal wording. @@ -599,15 +618,15 @@ class MCCFIInstruction { int64_t Offset, unsigned AddressSpace, SMLoc Loc) { - return {OpLLVMDefAspaceCfa, L, - CommonFields{Register, Offset, 0, AddressSpace}, Loc}; + return MCCFIInstruction(OpLLVMDefAspaceCfa, L, Register, Offset, + AddressSpace, Loc); } /// .cfi_offset Previous value of Register is saved at offset Offset /// from CFA. static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc = {}) { - return {OpOffset, L, CommonFields{Register, Offset}, Loc}; + return MCCFIInstruction(OpOffset, L, Register, Offset, Loc); } /// .cfi_rel_offset Previous value of Register is saved at offset @@ -615,30 +634,30 @@ class MCCFIInstruction { /// using the known displacement of the CFA register from the CFA. static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc = {}) { - return {OpRelOffset, L, CommonFields{Register, Offset}, Loc}; + return MCCFIInstruction(OpRelOffset, L, Register, Offset, Loc); } /// .cfi_register Previous value of Register1 is saved in /// register Register2. static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1, unsigned Register2, SMLoc Loc = {}) { - return {OpRegister, L, CommonFields{Register1, 0, Register2}, Loc}; + return MCCFIInstruction(OpRegister, L, Register1, Register2, Loc); } /// .cfi_window_save SPARC register window is saved. static MCCFIInstruction createWindowSave(MCSymbol *L, SMLoc Loc = {}) { - return {OpWindowSave, L, CommonFields{}, Loc}; + return MCCFIInstruction(OpWindowSave, L, 0, INT64_C(0), Loc); } /// .cfi_negate_ra_state AArch64 negate RA state. static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc = {}) { - return {OpNegateRAState, L, CommonFields{}, Loc}; + return MCCFIInstruction(OpNegateRAState, L, 0, INT64_C(0), Loc); } /// .cfi_negate_ra_state_with_pc AArch64 negate RA state with PC. static MCCFIInstruction createNegateRAStateWithPC(MCSymbol *L, SMLoc Loc = {}) { - return {OpNegateRAStateWithPC, L, CommonFields{}, Loc}; + return MCCFIInstruction(OpNegateRAStateWithPC, L, 0, INT64_C(0), Loc); } /// .cfi_restore says that the rule for Register is now the same as it @@ -646,106 +665,104 @@ class MCCFIInstruction { /// by .cfi_startproc were executed. static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register, SMLoc Loc = {}) { - return {OpRestore, L, CommonFields{Register}, Loc}; + return MCCFIInstruction(OpRestore, L, Register, INT64_C(0), Loc); } /// .cfi_undefined From now on the previous value of Register can't be /// restored anymore. static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register, SMLoc Loc = {}) { - return {OpUndefined, L, CommonFields{Register}, Loc}; + return MCCFIInstruction(OpUndefined, L, Register, INT64_C(0), Loc); } /// .cfi_same_value Current value of Register is the same as in the /// previous frame. I.e., no restoration is needed. static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register, SMLoc Loc = {}) { - return {OpSameValue, L, CommonFields{Register}, Loc}; + return MCCFIInstruction(OpSameValue, L, Register, INT64_C(0), Loc); } /// .cfi_remember_state Save all current rules for all registers. static MCCFIInstruction createRememberState(MCSymbol *L, SMLoc Loc = {}) { - return {OpRememberState, L, CommonFields{}, Loc}; + return MCCFIInstruction(OpRememberState, L, 0, INT64_C(0), Loc); } /// .cfi_restore_state Restore the previously saved state. static MCCFIInstruction createRestoreState(MCSymbol *L, SMLoc Loc = {}) { - return {OpRestoreState, L, CommonFields{}, Loc}; + return MCCFIInstruction(OpRestoreState, L, 0, INT64_C(0), Loc); } /// .cfi_escape Allows the user to add arbitrary bytes to the unwind /// info. static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals, SMLoc Loc = {}, StringRef Comment = "") { - return {OpEscape, L, - EscapeFields{std::vector(Vals.begin(), Vals.end()), - Comment.str()}, - Loc}; + return MCCFIInstruction(OpEscape, L, 0, 0, Loc, Vals, Comment); } /// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int64_t Size, SMLoc Loc = {}) { - return {OpGnuArgsSize, L, CommonFields{0, Size}, Loc}; + return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, Loc); } static MCCFIInstruction createLabel(MCSymbol *L, MCSymbol *CfiLabel, SMLoc Loc) { - return {OpLabel, L, LabelFields{CfiLabel}, Loc}; + return MCCFIInstruction(OpLabel, L, CfiLabel, Loc); } /// .cfi_val_offset Previous value of Register is offset Offset from the /// current CFA register. static MCCFIInstruction createValOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc = {}) { - return {OpValOffset, L, CommonFields{Register, Offset}, Loc}; + return MCCFIInstruction(OpValOffset, L, Register, Offset, Loc); } OpType getOperation() const { return Operation; } MCSymbol *getLabel() const { return Label; } unsigned getRegister() const { + if (Operation == OpRegister) + return U.RR.Register; + if (Operation == OpLLVMDefAspaceCfa) + return U.RIA.Register; assert(Operation == OpDefCfa || Operation == OpOffset || Operation == OpRestore || Operation == OpUndefined || Operation == OpSameValue || Operation == OpDefCfaRegister || - Operation == OpRelOffset || Operation == OpValOffset || - Operation == OpRegister || Operation == OpLLVMDefAspaceCfa); - return std::get(ExtraFields).Register; + Operation == OpRelOffset || Operation == OpValOffset); + return U.RI.Register; } unsigned getRegister2() const { assert(Operation == OpRegister); - return std::get(ExtraFields).Register2; + return U.RR.Register2; } unsigned getAddressSpace() const { assert(Operation == OpLLVMDefAspaceCfa); - return std::get(ExtraFields).AddressSpace; + return U.RIA.AddressSpace; } int64_t getOffset() const { + if (Operation == OpLLVMDefAspaceCfa) + return U.RIA.Offset; assert(Operation == OpDefCfa || Operation == OpOffset || Operation == OpRelOffset || Operation == OpDefCfaOffset || Operation == OpAdjustCfaOffset || Operation == OpGnuArgsSize || - Operation == OpValOffset || Operation == OpLLVMDefAspaceCfa); - return std::get(ExtraFields).Offset; + Operation == OpValOffset); + return U.RI.Offset; } MCSymbol *getCfiLabel() const { assert(Operation == OpLabel); - return std::get(ExtraFields).CfiLabel; + return U.CfiLabel; } StringRef getValues() const { assert(Operation == OpEscape); - auto &Values = std::get(ExtraFields).Values; return StringRef(&Values[0], Values.size()); } - StringRef getComment() const { - assert(Operation == OpEscape); - return std::get(ExtraFields).Comment; - } + StringRef getComment() const { return Comment; } SMLoc getLoc() const { return Loc; } };