diff --git a/llvm/include/llvm/MC/MCDwarf.h b/llvm/include/llvm/MC/MCDwarf.h index 547fb34a0696..7dc1c383bbf3 100644 --- a/llvm/include/llvm/MC/MCDwarf.h +++ b/llvm/include/llvm/MC/MCDwarf.h @@ -21,6 +21,7 @@ #include "llvm/MC/StringTableBuilder.h" #include "llvm/Support/Error.h" #include "llvm/Support/MD5.h" +#include "llvm/Support/SMLoc.h" #include "llvm/Support/StringSaver.h" #include #include @@ -39,7 +40,6 @@ class MCSection; class MCStreamer; class MCSymbol; class raw_ostream; -class SMLoc; class SourceMgr; namespace mcdwarf { @@ -507,52 +507,58 @@ private: unsigned Register2; }; unsigned AddressSpace = ~0u; + SMLoc Loc; std::vector Values; std::string Comment; - MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V, - StringRef Comment = "") - : Operation(Op), Label(L), Register(R), Offset(O), + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, SMLoc Loc, + StringRef V = "", StringRef Comment = "") + : Operation(Op), Label(L), Register(R), Offset(O), Loc(Loc), Values(V.begin(), V.end()), Comment(Comment) { assert(Op != OpRegister && Op != OpLLVMDefAspaceCfa); } - MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2) - : Operation(Op), Label(L), Register(R1), Register2(R2) { + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2, SMLoc Loc) + : Operation(Op), Label(L), Register(R1), Register2(R2), Loc(Loc) { assert(Op == OpRegister); } - MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, unsigned AS) - : Operation(Op), Label(L), Register(R), Offset(O), AddressSpace(AS) { + MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, unsigned AS, + SMLoc Loc) + : Operation(Op), Label(L), Register(R), Offset(O), AddressSpace(AS), + Loc(Loc) { assert(Op == OpLLVMDefAspaceCfa); } 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, - int Offset) { - return MCCFIInstruction(OpDefCfa, L, Register, Offset, ""); + static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int Offset, + SMLoc 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) { - return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, ""); + static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register, + SMLoc Loc = {}) { + return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, Loc); } /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register /// remains the same, but offset is new. Note that it is the absolute offset /// that will be added to a defined register to the compute CFA address. - static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset) { - return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, ""); + static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset, + SMLoc Loc = {}) { + return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, Loc); } /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but /// Offset is a relative value that is added/subtracted from the previous /// offset. - static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment) { - return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, ""); + static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment, + SMLoc Loc = {}) { + return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, Loc); } // FIXME: Update the remaining docs to use the new proposal wording. @@ -561,82 +567,87 @@ public: /// `DW_OP_constu AS; DW_OP_aspace_bregx R, B` as a location description. static MCCFIInstruction createLLVMDefAspaceCfa(MCSymbol *L, unsigned Register, int Offset, - unsigned AddressSpace) { + unsigned AddressSpace, + SMLoc Loc) { return MCCFIInstruction(OpLLVMDefAspaceCfa, L, Register, Offset, - AddressSpace); + AddressSpace, Loc); } /// .cfi_offset Previous value of Register is saved at offset Offset /// from CFA. static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, - int Offset) { - return MCCFIInstruction(OpOffset, L, Register, Offset, ""); + int Offset, SMLoc Loc = {}) { + return MCCFIInstruction(OpOffset, L, Register, Offset, Loc); } /// .cfi_rel_offset Previous value of Register is saved at offset /// Offset from the current CFA register. This is transformed to .cfi_offset /// using the known displacement of the CFA register from the CFA. static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, - int Offset) { - return MCCFIInstruction(OpRelOffset, L, Register, Offset, ""); + int Offset, SMLoc 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) { - return MCCFIInstruction(OpRegister, L, Register1, Register2); + unsigned Register2, SMLoc Loc = {}) { + return MCCFIInstruction(OpRegister, L, Register1, Register2, Loc); } /// .cfi_window_save SPARC register window is saved. - static MCCFIInstruction createWindowSave(MCSymbol *L) { - return MCCFIInstruction(OpWindowSave, L, 0, 0, ""); + static MCCFIInstruction createWindowSave(MCSymbol *L, SMLoc Loc = {}) { + return MCCFIInstruction(OpWindowSave, L, 0, 0, Loc); } /// .cfi_negate_ra_state AArch64 negate RA state. - static MCCFIInstruction createNegateRAState(MCSymbol *L) { - return MCCFIInstruction(OpNegateRAState, L, 0, 0, ""); + static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc = {}) { + return MCCFIInstruction(OpNegateRAState, L, 0, 0, Loc); } /// .cfi_restore says that the rule for Register is now the same as it /// was at the beginning of the function, after all initial instructions added /// by .cfi_startproc were executed. - static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register) { - return MCCFIInstruction(OpRestore, L, Register, 0, ""); + static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register, + SMLoc Loc = {}) { + return MCCFIInstruction(OpRestore, L, Register, 0, Loc); } /// .cfi_undefined From now on the previous value of Register can't be /// restored anymore. - static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register) { - return MCCFIInstruction(OpUndefined, L, Register, 0, ""); + static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register, + SMLoc Loc = {}) { + return MCCFIInstruction(OpUndefined, L, Register, 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) { - return MCCFIInstruction(OpSameValue, L, Register, 0, ""); + static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register, + SMLoc Loc = {}) { + return MCCFIInstruction(OpSameValue, L, Register, 0, Loc); } /// .cfi_remember_state Save all current rules for all registers. - static MCCFIInstruction createRememberState(MCSymbol *L) { - return MCCFIInstruction(OpRememberState, L, 0, 0, ""); + static MCCFIInstruction createRememberState(MCSymbol *L, SMLoc Loc = {}) { + return MCCFIInstruction(OpRememberState, L, 0, 0, Loc); } /// .cfi_restore_state Restore the previously saved state. - static MCCFIInstruction createRestoreState(MCSymbol *L) { - return MCCFIInstruction(OpRestoreState, L, 0, 0, ""); + static MCCFIInstruction createRestoreState(MCSymbol *L, SMLoc Loc = {}) { + return MCCFIInstruction(OpRestoreState, L, 0, 0, Loc); } /// .cfi_escape Allows the user to add arbitrary bytes to the unwind /// info. static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals, - StringRef Comment = "") { - return MCCFIInstruction(OpEscape, L, 0, 0, Vals, Comment); + SMLoc Loc = {}, StringRef Comment = "") { + 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, int Size) { - return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, ""); + static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size, + SMLoc Loc = {}) { + return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, Loc); } OpType getOperation() const { return Operation; } @@ -674,9 +685,8 @@ public: return StringRef(&Values[0], Values.size()); } - StringRef getComment() const { - return Comment; - } + StringRef getComment() const { return Comment; } + SMLoc getLoc() const { return Loc; } }; struct MCDwarfFrameInfo { diff --git a/llvm/include/llvm/MC/MCObjectStreamer.h b/llvm/include/llvm/MC/MCObjectStreamer.h index 865b914f88c9..5e5b4b315017 100644 --- a/llvm/include/llvm/MC/MCObjectStreamer.h +++ b/llvm/include/llvm/MC/MCObjectStreamer.h @@ -168,7 +168,7 @@ public: unsigned PointerSize) override; void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel) override; void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel, - const MCSymbol *Label); + const MCSymbol *Label, SMLoc Loc); void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc) override; diff --git a/llvm/include/llvm/MC/MCStreamer.h b/llvm/include/llvm/MC/MCStreamer.h index 8b081db4dedd..5f12fcc1c840 100644 --- a/llvm/include/llvm/MC/MCStreamer.h +++ b/llvm/include/llvm/MC/MCStreamer.h @@ -1025,28 +1025,29 @@ public: virtual void emitCFISections(bool EH, bool Debug); void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc()); void emitCFIEndProc(); - virtual void emitCFIDefCfa(int64_t Register, int64_t Offset); - virtual void emitCFIDefCfaOffset(int64_t Offset); - virtual void emitCFIDefCfaRegister(int64_t Register); + virtual void emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc = {}); + virtual void emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc = {}); + virtual void emitCFIDefCfaRegister(int64_t Register, SMLoc Loc = {}); virtual void emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, - int64_t AddressSpace); - virtual void emitCFIOffset(int64_t Register, int64_t Offset); + int64_t AddressSpace, SMLoc Loc = {}); + virtual void emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc = {}); virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding); virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding); - virtual void emitCFIRememberState(); - virtual void emitCFIRestoreState(); - virtual void emitCFISameValue(int64_t Register); - virtual void emitCFIRestore(int64_t Register); - virtual void emitCFIRelOffset(int64_t Register, int64_t Offset); - virtual void emitCFIAdjustCfaOffset(int64_t Adjustment); - virtual void emitCFIEscape(StringRef Values); + virtual void emitCFIRememberState(SMLoc Loc); + virtual void emitCFIRestoreState(SMLoc Loc); + virtual void emitCFISameValue(int64_t Register, SMLoc Loc = {}); + virtual void emitCFIRestore(int64_t Register, SMLoc Loc = {}); + virtual void emitCFIRelOffset(int64_t Register, int64_t Offset, SMLoc Loc); + virtual void emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc = {}); + virtual void emitCFIEscape(StringRef Values, SMLoc Loc = {}); virtual void emitCFIReturnColumn(int64_t Register); - virtual void emitCFIGnuArgsSize(int64_t Size); + virtual void emitCFIGnuArgsSize(int64_t Size, SMLoc Loc = {}); virtual void emitCFISignalFrame(); - virtual void emitCFIUndefined(int64_t Register); - virtual void emitCFIRegister(int64_t Register1, int64_t Register2); - virtual void emitCFIWindowSave(); - virtual void emitCFINegateRAState(); + virtual void emitCFIUndefined(int64_t Register, SMLoc Loc = {}); + virtual void emitCFIRegister(int64_t Register1, int64_t Register2, + SMLoc Loc = {}); + virtual void emitCFIWindowSave(SMLoc Loc = {}); + virtual void emitCFINegateRAState(SMLoc Loc = {}); virtual void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc()); virtual void emitWinCFIEndProc(SMLoc Loc = SMLoc()); diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp index 1d5ddef17338..21d0d070c247 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp @@ -204,58 +204,59 @@ void AsmPrinter::emitCallSiteValue(uint64_t Value, unsigned Encoding) const { //===----------------------------------------------------------------------===// void AsmPrinter::emitCFIInstruction(const MCCFIInstruction &Inst) const { + SMLoc Loc = Inst.getLoc(); switch (Inst.getOperation()) { default: llvm_unreachable("Unexpected instruction"); case MCCFIInstruction::OpDefCfaOffset: - OutStreamer->emitCFIDefCfaOffset(Inst.getOffset()); + OutStreamer->emitCFIDefCfaOffset(Inst.getOffset(), Loc); break; case MCCFIInstruction::OpAdjustCfaOffset: - OutStreamer->emitCFIAdjustCfaOffset(Inst.getOffset()); + OutStreamer->emitCFIAdjustCfaOffset(Inst.getOffset(), Loc); break; case MCCFIInstruction::OpDefCfa: - OutStreamer->emitCFIDefCfa(Inst.getRegister(), Inst.getOffset()); + OutStreamer->emitCFIDefCfa(Inst.getRegister(), Inst.getOffset(), Loc); break; case MCCFIInstruction::OpDefCfaRegister: - OutStreamer->emitCFIDefCfaRegister(Inst.getRegister()); + OutStreamer->emitCFIDefCfaRegister(Inst.getRegister(), Loc); break; case MCCFIInstruction::OpLLVMDefAspaceCfa: OutStreamer->emitCFILLVMDefAspaceCfa(Inst.getRegister(), Inst.getOffset(), - Inst.getAddressSpace()); + Inst.getAddressSpace(), Loc); break; case MCCFIInstruction::OpOffset: - OutStreamer->emitCFIOffset(Inst.getRegister(), Inst.getOffset()); + OutStreamer->emitCFIOffset(Inst.getRegister(), Inst.getOffset(), Loc); break; case MCCFIInstruction::OpRegister: - OutStreamer->emitCFIRegister(Inst.getRegister(), Inst.getRegister2()); + OutStreamer->emitCFIRegister(Inst.getRegister(), Inst.getRegister2(), Loc); break; case MCCFIInstruction::OpWindowSave: - OutStreamer->emitCFIWindowSave(); + OutStreamer->emitCFIWindowSave(Loc); break; case MCCFIInstruction::OpNegateRAState: - OutStreamer->emitCFINegateRAState(); + OutStreamer->emitCFINegateRAState(Loc); break; case MCCFIInstruction::OpSameValue: - OutStreamer->emitCFISameValue(Inst.getRegister()); + OutStreamer->emitCFISameValue(Inst.getRegister(), Loc); break; case MCCFIInstruction::OpGnuArgsSize: - OutStreamer->emitCFIGnuArgsSize(Inst.getOffset()); + OutStreamer->emitCFIGnuArgsSize(Inst.getOffset(), Loc); break; case MCCFIInstruction::OpEscape: OutStreamer->AddComment(Inst.getComment()); - OutStreamer->emitCFIEscape(Inst.getValues()); + OutStreamer->emitCFIEscape(Inst.getValues(), Loc); break; case MCCFIInstruction::OpRestore: - OutStreamer->emitCFIRestore(Inst.getRegister()); + OutStreamer->emitCFIRestore(Inst.getRegister(), Loc); break; case MCCFIInstruction::OpUndefined: - OutStreamer->emitCFIUndefined(Inst.getRegister()); + OutStreamer->emitCFIUndefined(Inst.getRegister(), Loc); break; case MCCFIInstruction::OpRememberState: - OutStreamer->emitCFIRememberState(); + OutStreamer->emitCFIRememberState(Loc); break; case MCCFIInstruction::OpRestoreState: - OutStreamer->emitCFIRestoreState(); + OutStreamer->emitCFIRestoreState(Loc); break; } } diff --git a/llvm/lib/CodeGen/MIRParser/MIParser.cpp b/llvm/lib/CodeGen/MIRParser/MIParser.cpp index f2df73ef3f20..bfd9286ff59c 100644 --- a/llvm/lib/CodeGen/MIRParser/MIParser.cpp +++ b/llvm/lib/CodeGen/MIRParser/MIParser.cpp @@ -2523,7 +2523,7 @@ bool MIParser::parseCFIOperand(MachineOperand &Dest) { parseCFIAddressSpace(AddressSpace)) return true; CFIIndex = MF.addFrameInst(MCCFIInstruction::createLLVMDefAspaceCfa( - nullptr, Reg, Offset, AddressSpace)); + nullptr, Reg, Offset, AddressSpace, SMLoc())); break; case MIToken::kw_cfi_remember_state: CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr)); diff --git a/llvm/lib/MC/MCAsmStreamer.cpp b/llvm/lib/MC/MCAsmStreamer.cpp index de48c9e965f1..78950ed0b095 100644 --- a/llvm/lib/MC/MCAsmStreamer.cpp +++ b/llvm/lib/MC/MCAsmStreamer.cpp @@ -328,27 +328,28 @@ public: void emitCFIBKeyFrame() override; void emitCFIMTETaggedFrame() override; void emitCFISections(bool EH, bool Debug) override; - void emitCFIDefCfa(int64_t Register, int64_t Offset) override; - void emitCFIDefCfaOffset(int64_t Offset) override; - void emitCFIDefCfaRegister(int64_t Register) override; + void emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc) override; + void emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc) override; + void emitCFIDefCfaRegister(int64_t Register, SMLoc Loc) override; void emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, - int64_t AddressSpace) override; - void emitCFIOffset(int64_t Register, int64_t Offset) override; + int64_t AddressSpace, SMLoc Loc) override; + void emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc) override; void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding) override; void emitCFILsda(const MCSymbol *Sym, unsigned Encoding) override; - void emitCFIRememberState() override; - void emitCFIRestoreState() override; - void emitCFIRestore(int64_t Register) override; - void emitCFISameValue(int64_t Register) override; - void emitCFIRelOffset(int64_t Register, int64_t Offset) override; - void emitCFIAdjustCfaOffset(int64_t Adjustment) override; - void emitCFIEscape(StringRef Values) override; - void emitCFIGnuArgsSize(int64_t Size) override; + void emitCFIRememberState(SMLoc Loc) override; + void emitCFIRestoreState(SMLoc Loc) override; + void emitCFIRestore(int64_t Register, SMLoc Loc) override; + void emitCFISameValue(int64_t Register, SMLoc Loc) override; + void emitCFIRelOffset(int64_t Register, int64_t Offset, SMLoc Loc) override; + void emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc) override; + void emitCFIEscape(StringRef Values, SMLoc Loc) override; + void emitCFIGnuArgsSize(int64_t Size, SMLoc Loc) override; void emitCFISignalFrame() override; - void emitCFIUndefined(int64_t Register) override; - void emitCFIRegister(int64_t Register1, int64_t Register2) override; - void emitCFIWindowSave() override; - void emitCFINegateRAState() override; + void emitCFIUndefined(int64_t Register, SMLoc Loc) override; + void emitCFIRegister(int64_t Register1, int64_t Register2, + SMLoc Loc) override; + void emitCFIWindowSave(SMLoc Loc) override; + void emitCFINegateRAState(SMLoc Loc) override; void emitCFIReturnColumn(int64_t Register) override; void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) override; @@ -1897,23 +1898,23 @@ void MCAsmStreamer::EmitRegisterName(int64_t Register) { OS << Register; } -void MCAsmStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) { - MCStreamer::emitCFIDefCfa(Register, Offset); +void MCAsmStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc) { + MCStreamer::emitCFIDefCfa(Register, Offset, Loc); OS << "\t.cfi_def_cfa "; EmitRegisterName(Register); OS << ", " << Offset; EmitEOL(); } -void MCAsmStreamer::emitCFIDefCfaOffset(int64_t Offset) { - MCStreamer::emitCFIDefCfaOffset(Offset); +void MCAsmStreamer::emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc) { + MCStreamer::emitCFIDefCfaOffset(Offset, Loc); OS << "\t.cfi_def_cfa_offset " << Offset; EmitEOL(); } void MCAsmStreamer::emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, - int64_t AddressSpace) { - MCStreamer::emitCFILLVMDefAspaceCfa(Register, Offset, AddressSpace); + int64_t AddressSpace, SMLoc Loc) { + MCStreamer::emitCFILLVMDefAspaceCfa(Register, Offset, AddressSpace, Loc); OS << "\t.cfi_llvm_def_aspace_cfa "; EmitRegisterName(Register); OS << ", " << Offset; @@ -1931,14 +1932,14 @@ static void PrintCFIEscape(llvm::formatted_raw_ostream &OS, StringRef Values) { } } -void MCAsmStreamer::emitCFIEscape(StringRef Values) { - MCStreamer::emitCFIEscape(Values); +void MCAsmStreamer::emitCFIEscape(StringRef Values, SMLoc Loc) { + MCStreamer::emitCFIEscape(Values, Loc); PrintCFIEscape(OS, Values); EmitEOL(); } -void MCAsmStreamer::emitCFIGnuArgsSize(int64_t Size) { - MCStreamer::emitCFIGnuArgsSize(Size); +void MCAsmStreamer::emitCFIGnuArgsSize(int64_t Size, SMLoc Loc) { + MCStreamer::emitCFIGnuArgsSize(Size, Loc); uint8_t Buffer[16] = { dwarf::DW_CFA_GNU_args_size }; unsigned Len = encodeULEB128(Size, Buffer + 1) + 1; @@ -1947,15 +1948,15 @@ void MCAsmStreamer::emitCFIGnuArgsSize(int64_t Size) { EmitEOL(); } -void MCAsmStreamer::emitCFIDefCfaRegister(int64_t Register) { - MCStreamer::emitCFIDefCfaRegister(Register); +void MCAsmStreamer::emitCFIDefCfaRegister(int64_t Register, SMLoc Loc) { + MCStreamer::emitCFIDefCfaRegister(Register, Loc); OS << "\t.cfi_def_cfa_register "; EmitRegisterName(Register); EmitEOL(); } -void MCAsmStreamer::emitCFIOffset(int64_t Register, int64_t Offset) { - this->MCStreamer::emitCFIOffset(Register, Offset); +void MCAsmStreamer::emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc) { + MCStreamer::emitCFIOffset(Register, Offset, Loc); OS << "\t.cfi_offset "; EmitRegisterName(Register); OS << ", " << Offset; @@ -1977,42 +1978,43 @@ void MCAsmStreamer::emitCFILsda(const MCSymbol *Sym, unsigned Encoding) { EmitEOL(); } -void MCAsmStreamer::emitCFIRememberState() { - MCStreamer::emitCFIRememberState(); +void MCAsmStreamer::emitCFIRememberState(SMLoc Loc) { + MCStreamer::emitCFIRememberState(Loc); OS << "\t.cfi_remember_state"; EmitEOL(); } -void MCAsmStreamer::emitCFIRestoreState() { - MCStreamer::emitCFIRestoreState(); +void MCAsmStreamer::emitCFIRestoreState(SMLoc Loc) { + MCStreamer::emitCFIRestoreState(Loc); OS << "\t.cfi_restore_state"; EmitEOL(); } -void MCAsmStreamer::emitCFIRestore(int64_t Register) { - MCStreamer::emitCFIRestore(Register); +void MCAsmStreamer::emitCFIRestore(int64_t Register, SMLoc Loc) { + MCStreamer::emitCFIRestore(Register, Loc); OS << "\t.cfi_restore "; EmitRegisterName(Register); EmitEOL(); } -void MCAsmStreamer::emitCFISameValue(int64_t Register) { - MCStreamer::emitCFISameValue(Register); +void MCAsmStreamer::emitCFISameValue(int64_t Register, SMLoc Loc) { + MCStreamer::emitCFISameValue(Register, Loc); OS << "\t.cfi_same_value "; EmitRegisterName(Register); EmitEOL(); } -void MCAsmStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset) { - MCStreamer::emitCFIRelOffset(Register, Offset); +void MCAsmStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset, + SMLoc Loc) { + MCStreamer::emitCFIRelOffset(Register, Offset, Loc); OS << "\t.cfi_rel_offset "; EmitRegisterName(Register); OS << ", " << Offset; EmitEOL(); } -void MCAsmStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment) { - MCStreamer::emitCFIAdjustCfaOffset(Adjustment); +void MCAsmStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc) { + MCStreamer::emitCFIAdjustCfaOffset(Adjustment, Loc); OS << "\t.cfi_adjust_cfa_offset " << Adjustment; EmitEOL(); } @@ -2023,15 +2025,16 @@ void MCAsmStreamer::emitCFISignalFrame() { EmitEOL(); } -void MCAsmStreamer::emitCFIUndefined(int64_t Register) { - MCStreamer::emitCFIUndefined(Register); +void MCAsmStreamer::emitCFIUndefined(int64_t Register, SMLoc Loc) { + MCStreamer::emitCFIUndefined(Register, Loc); OS << "\t.cfi_undefined "; EmitRegisterName(Register); EmitEOL(); } -void MCAsmStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) { - MCStreamer::emitCFIRegister(Register1, Register2); +void MCAsmStreamer::emitCFIRegister(int64_t Register1, int64_t Register2, + SMLoc Loc) { + MCStreamer::emitCFIRegister(Register1, Register2, Loc); OS << "\t.cfi_register "; EmitRegisterName(Register1); OS << ", "; @@ -2039,14 +2042,14 @@ void MCAsmStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) { EmitEOL(); } -void MCAsmStreamer::emitCFIWindowSave() { - MCStreamer::emitCFIWindowSave(); +void MCAsmStreamer::emitCFIWindowSave(SMLoc Loc) { + MCStreamer::emitCFIWindowSave(Loc); OS << "\t.cfi_window_save"; EmitEOL(); } -void MCAsmStreamer::emitCFINegateRAState() { - MCStreamer::emitCFINegateRAState(); +void MCAsmStreamer::emitCFINegateRAState(SMLoc Loc) { + MCStreamer::emitCFINegateRAState(Loc); OS << "\t.cfi_negate_ra_state"; EmitEOL(); } diff --git a/llvm/lib/MC/MCDwarf.cpp b/llvm/lib/MC/MCDwarf.cpp index 9506b5cd5929..4d21098553fe 100644 --- a/llvm/lib/MC/MCDwarf.cpp +++ b/llvm/lib/MC/MCDwarf.cpp @@ -1476,7 +1476,7 @@ void FrameEmitterImpl::emitCFIInstructions(ArrayRef Instrs, if (BaseLabel && Label) { MCSymbol *ThisSym = Label; if (ThisSym != BaseLabel) { - Streamer.emitDwarfAdvanceFrameAddr(BaseLabel, ThisSym); + Streamer.emitDwarfAdvanceFrameAddr(BaseLabel, ThisSym, {}); BaseLabel = ThisSym; } } diff --git a/llvm/lib/MC/MCObjectStreamer.cpp b/llvm/lib/MC/MCObjectStreamer.cpp index 64fbe618b57f..9398eb85618a 100644 --- a/llvm/lib/MC/MCObjectStreamer.cpp +++ b/llvm/lib/MC/MCObjectStreamer.cpp @@ -510,13 +510,13 @@ void MCObjectStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line, } static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A, - const MCSymbol *B) { + const MCSymbol *B, SMLoc Loc) { MCContext &Context = OS.getContext(); MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context); const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context); const MCExpr *AddrDelta = - MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context); + MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context, Loc); return AddrDelta; } @@ -543,7 +543,7 @@ void MCObjectStreamer::emitDwarfAdvanceLineAddr(int64_t LineDelta, Label, PointerSize); return; } - const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel); + const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, SMLoc()); insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta)); } @@ -566,9 +566,10 @@ void MCObjectStreamer::emitDwarfLineEndEntry(MCSection *Section, } void MCObjectStreamer::emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel, - const MCSymbol *Label) { - const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel); - insert(new MCDwarfCallFrameFragment(*AddrDelta)); + const MCSymbol *Label, + SMLoc Loc) { + const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, Loc); + insert(new MCDwarfCallFrameFragment(*AddrDelta, nullptr)); } void MCObjectStreamer::emitCVLocDirective(unsigned FunctionId, unsigned FileNo, diff --git a/llvm/lib/MC/MCParser/AsmParser.cpp b/llvm/lib/MC/MCParser/AsmParser.cpp index 7f0f316b3382..2c81c33c92d5 100644 --- a/llvm/lib/MC/MCParser/AsmParser.cpp +++ b/llvm/lib/MC/MCParser/AsmParser.cpp @@ -601,25 +601,25 @@ private: // .cfi directives bool parseDirectiveCFIRegister(SMLoc DirectiveLoc); - bool parseDirectiveCFIWindowSave(); + bool parseDirectiveCFIWindowSave(SMLoc DirectiveLoc); bool parseDirectiveCFISections(); bool parseDirectiveCFIStartProc(); bool parseDirectiveCFIEndProc(); - bool parseDirectiveCFIDefCfaOffset(); + bool parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc); - bool parseDirectiveCFIAdjustCfaOffset(); + bool parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc); bool parseDirectiveCFILLVMDefAspaceCfa(SMLoc DirectiveLoc); bool parseDirectiveCFIOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIPersonalityOrLsda(bool IsPersonality); - bool parseDirectiveCFIRememberState(); - bool parseDirectiveCFIRestoreState(); + bool parseDirectiveCFIRememberState(SMLoc DirectiveLoc); + bool parseDirectiveCFIRestoreState(SMLoc DirectiveLoc); bool parseDirectiveCFISameValue(SMLoc DirectiveLoc); bool parseDirectiveCFIRestore(SMLoc DirectiveLoc); - bool parseDirectiveCFIEscape(); + bool parseDirectiveCFIEscape(SMLoc DirectiveLoc); bool parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc); - bool parseDirectiveCFISignalFrame(); + bool parseDirectiveCFISignalFrame(SMLoc DirectiveLoc); bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc); // macro directives @@ -2195,9 +2195,9 @@ bool AsmParser::parseStatement(ParseStatementInfo &Info, case DK_CFI_DEF_CFA: return parseDirectiveCFIDefCfa(IDLoc); case DK_CFI_DEF_CFA_OFFSET: - return parseDirectiveCFIDefCfaOffset(); + return parseDirectiveCFIDefCfaOffset(IDLoc); case DK_CFI_ADJUST_CFA_OFFSET: - return parseDirectiveCFIAdjustCfaOffset(); + return parseDirectiveCFIAdjustCfaOffset(IDLoc); case DK_CFI_DEF_CFA_REGISTER: return parseDirectiveCFIDefCfaRegister(IDLoc); case DK_CFI_LLVM_DEF_ASPACE_CFA: @@ -2211,25 +2211,25 @@ bool AsmParser::parseStatement(ParseStatementInfo &Info, case DK_CFI_LSDA: return parseDirectiveCFIPersonalityOrLsda(false); case DK_CFI_REMEMBER_STATE: - return parseDirectiveCFIRememberState(); + return parseDirectiveCFIRememberState(IDLoc); case DK_CFI_RESTORE_STATE: - return parseDirectiveCFIRestoreState(); + return parseDirectiveCFIRestoreState(IDLoc); case DK_CFI_SAME_VALUE: return parseDirectiveCFISameValue(IDLoc); case DK_CFI_RESTORE: return parseDirectiveCFIRestore(IDLoc); case DK_CFI_ESCAPE: - return parseDirectiveCFIEscape(); + return parseDirectiveCFIEscape(IDLoc); case DK_CFI_RETURN_COLUMN: return parseDirectiveCFIReturnColumn(IDLoc); case DK_CFI_SIGNAL_FRAME: - return parseDirectiveCFISignalFrame(); + return parseDirectiveCFISignalFrame(IDLoc); case DK_CFI_UNDEFINED: return parseDirectiveCFIUndefined(IDLoc); case DK_CFI_REGISTER: return parseDirectiveCFIRegister(IDLoc); case DK_CFI_WINDOW_SAVE: - return parseDirectiveCFIWindowSave(); + return parseDirectiveCFIWindowSave(IDLoc); case DK_MACROS_ON: case DK_MACROS_OFF: return parseDirectiveMacrosOnOff(IDVal); @@ -4238,18 +4238,18 @@ bool AsmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) { parseAbsoluteExpression(Offset) || parseEOL()) return true; - getStreamer().emitCFIDefCfa(Register, Offset); + getStreamer().emitCFIDefCfa(Register, Offset, DirectiveLoc); return false; } /// parseDirectiveCFIDefCfaOffset /// ::= .cfi_def_cfa_offset offset -bool AsmParser::parseDirectiveCFIDefCfaOffset() { +bool AsmParser::parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc) { int64_t Offset = 0; if (parseAbsoluteExpression(Offset) || parseEOL()) return true; - getStreamer().emitCFIDefCfaOffset(Offset); + getStreamer().emitCFIDefCfaOffset(Offset, DirectiveLoc); return false; } @@ -4261,27 +4261,27 @@ bool AsmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) { parseRegisterOrRegisterNumber(Register2, DirectiveLoc) || parseEOL()) return true; - getStreamer().emitCFIRegister(Register1, Register2); + getStreamer().emitCFIRegister(Register1, Register2, DirectiveLoc); return false; } /// parseDirectiveCFIWindowSave /// ::= .cfi_window_save -bool AsmParser::parseDirectiveCFIWindowSave() { +bool AsmParser::parseDirectiveCFIWindowSave(SMLoc DirectiveLoc) { if (parseEOL()) return true; - getStreamer().emitCFIWindowSave(); + getStreamer().emitCFIWindowSave(DirectiveLoc); return false; } /// parseDirectiveCFIAdjustCfaOffset /// ::= .cfi_adjust_cfa_offset adjustment -bool AsmParser::parseDirectiveCFIAdjustCfaOffset() { +bool AsmParser::parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc) { int64_t Adjustment = 0; if (parseAbsoluteExpression(Adjustment) || parseEOL()) return true; - getStreamer().emitCFIAdjustCfaOffset(Adjustment); + getStreamer().emitCFIAdjustCfaOffset(Adjustment, DirectiveLoc); return false; } @@ -4292,7 +4292,7 @@ bool AsmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) { if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL()) return true; - getStreamer().emitCFIDefCfaRegister(Register); + getStreamer().emitCFIDefCfaRegister(Register, DirectiveLoc); return false; } @@ -4305,7 +4305,8 @@ bool AsmParser::parseDirectiveCFILLVMDefAspaceCfa(SMLoc DirectiveLoc) { parseAbsoluteExpression(AddressSpace) || parseEOL()) return true; - getStreamer().emitCFILLVMDefAspaceCfa(Register, Offset, AddressSpace); + getStreamer().emitCFILLVMDefAspaceCfa(Register, Offset, AddressSpace, + DirectiveLoc); return false; } @@ -4319,7 +4320,7 @@ bool AsmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) { parseAbsoluteExpression(Offset) || parseEOL()) return true; - getStreamer().emitCFIOffset(Register, Offset); + getStreamer().emitCFIOffset(Register, Offset, DirectiveLoc); return false; } @@ -4332,7 +4333,7 @@ bool AsmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) { parseAbsoluteExpression(Offset) || parseEOL()) return true; - getStreamer().emitCFIRelOffset(Register, Offset); + getStreamer().emitCFIRelOffset(Register, Offset, DirectiveLoc); return false; } @@ -4387,19 +4388,19 @@ bool AsmParser::parseDirectiveCFIPersonalityOrLsda(bool IsPersonality) { /// parseDirectiveCFIRememberState /// ::= .cfi_remember_state -bool AsmParser::parseDirectiveCFIRememberState() { +bool AsmParser::parseDirectiveCFIRememberState(SMLoc DirectiveLoc) { if (parseEOL()) return true; - getStreamer().emitCFIRememberState(); + getStreamer().emitCFIRememberState(DirectiveLoc); return false; } /// parseDirectiveCFIRestoreState /// ::= .cfi_remember_state -bool AsmParser::parseDirectiveCFIRestoreState() { +bool AsmParser::parseDirectiveCFIRestoreState(SMLoc DirectiveLoc) { if (parseEOL()) return true; - getStreamer().emitCFIRestoreState(); + getStreamer().emitCFIRestoreState(DirectiveLoc); return false; } @@ -4411,7 +4412,7 @@ bool AsmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) { if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL()) return true; - getStreamer().emitCFISameValue(Register); + getStreamer().emitCFISameValue(Register, DirectiveLoc); return false; } @@ -4422,13 +4423,13 @@ bool AsmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) { if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL()) return true; - getStreamer().emitCFIRestore(Register); + getStreamer().emitCFIRestore(Register, DirectiveLoc); return false; } /// parseDirectiveCFIEscape /// ::= .cfi_escape expression[,...] -bool AsmParser::parseDirectiveCFIEscape() { +bool AsmParser::parseDirectiveCFIEscape(SMLoc DirectiveLoc) { std::string Values; int64_t CurrValue; if (parseAbsoluteExpression(CurrValue)) @@ -4445,7 +4446,7 @@ bool AsmParser::parseDirectiveCFIEscape() { Values.push_back((uint8_t)CurrValue); } - getStreamer().emitCFIEscape(Values); + getStreamer().emitCFIEscape(Values, DirectiveLoc); return false; } @@ -4461,7 +4462,7 @@ bool AsmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) { /// parseDirectiveCFISignalFrame /// ::= .cfi_signal_frame -bool AsmParser::parseDirectiveCFISignalFrame() { +bool AsmParser::parseDirectiveCFISignalFrame(SMLoc DirectiveLoc) { if (parseEOL()) return true; @@ -4477,7 +4478,7 @@ bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) { if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL()) return true; - getStreamer().emitCFIUndefined(Register); + getStreamer().emitCFIUndefined(Register, DirectiveLoc); return false; } diff --git a/llvm/lib/MC/MCParser/MasmParser.cpp b/llvm/lib/MC/MCParser/MasmParser.cpp index d522b77c2587..d41df71edbdf 100644 --- a/llvm/lib/MC/MCParser/MasmParser.cpp +++ b/llvm/lib/MC/MCParser/MasmParser.cpp @@ -962,22 +962,22 @@ private: // .cfi directives bool parseDirectiveCFIRegister(SMLoc DirectiveLoc); - bool parseDirectiveCFIWindowSave(); + bool parseDirectiveCFIWindowSave(SMLoc DirectiveLoc); bool parseDirectiveCFISections(); bool parseDirectiveCFIStartProc(); bool parseDirectiveCFIEndProc(); - bool parseDirectiveCFIDefCfaOffset(); + bool parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIDefCfa(SMLoc DirectiveLoc); - bool parseDirectiveCFIAdjustCfaOffset(); + bool parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc); bool parseDirectiveCFIOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIRelOffset(SMLoc DirectiveLoc); bool parseDirectiveCFIPersonalityOrLsda(bool IsPersonality); - bool parseDirectiveCFIRememberState(); - bool parseDirectiveCFIRestoreState(); + bool parseDirectiveCFIRememberState(SMLoc DirectiveLoc); + bool parseDirectiveCFIRestoreState(SMLoc DirectiveLoc); bool parseDirectiveCFISameValue(SMLoc DirectiveLoc); bool parseDirectiveCFIRestore(SMLoc DirectiveLoc); - bool parseDirectiveCFIEscape(); + bool parseDirectiveCFIEscape(SMLoc DirectiveLoc); bool parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc); bool parseDirectiveCFISignalFrame(); bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc); @@ -2426,9 +2426,9 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info, case DK_CFI_DEF_CFA: return parseDirectiveCFIDefCfa(IDLoc); case DK_CFI_DEF_CFA_OFFSET: - return parseDirectiveCFIDefCfaOffset(); + return parseDirectiveCFIDefCfaOffset(IDLoc); case DK_CFI_ADJUST_CFA_OFFSET: - return parseDirectiveCFIAdjustCfaOffset(); + return parseDirectiveCFIAdjustCfaOffset(IDLoc); case DK_CFI_DEF_CFA_REGISTER: return parseDirectiveCFIDefCfaRegister(IDLoc); case DK_CFI_OFFSET: @@ -2440,15 +2440,15 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info, case DK_CFI_LSDA: return parseDirectiveCFIPersonalityOrLsda(false); case DK_CFI_REMEMBER_STATE: - return parseDirectiveCFIRememberState(); + return parseDirectiveCFIRememberState(IDLoc); case DK_CFI_RESTORE_STATE: - return parseDirectiveCFIRestoreState(); + return parseDirectiveCFIRestoreState(IDLoc); case DK_CFI_SAME_VALUE: return parseDirectiveCFISameValue(IDLoc); case DK_CFI_RESTORE: return parseDirectiveCFIRestore(IDLoc); case DK_CFI_ESCAPE: - return parseDirectiveCFIEscape(); + return parseDirectiveCFIEscape(IDLoc); case DK_CFI_RETURN_COLUMN: return parseDirectiveCFIReturnColumn(IDLoc); case DK_CFI_SIGNAL_FRAME: @@ -2458,7 +2458,7 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info, case DK_CFI_REGISTER: return parseDirectiveCFIRegister(IDLoc); case DK_CFI_WINDOW_SAVE: - return parseDirectiveCFIWindowSave(); + return parseDirectiveCFIWindowSave(IDLoc); case DK_EXITM: Info.ExitValue = ""; return parseDirectiveExitMacro(IDLoc, IDVal, *Info.ExitValue); @@ -5531,12 +5531,12 @@ bool MasmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) { /// parseDirectiveCFIDefCfaOffset /// ::= .cfi_def_cfa_offset offset -bool MasmParser::parseDirectiveCFIDefCfaOffset() { +bool MasmParser::parseDirectiveCFIDefCfaOffset(SMLoc DirectiveLoc) { int64_t Offset = 0; if (parseAbsoluteExpression(Offset)) return true; - getStreamer().emitCFIDefCfaOffset(Offset); + getStreamer().emitCFIDefCfaOffset(Offset, DirectiveLoc); return false; } @@ -5549,25 +5549,25 @@ bool MasmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) { parseRegisterOrRegisterNumber(Register2, DirectiveLoc)) return true; - getStreamer().emitCFIRegister(Register1, Register2); + getStreamer().emitCFIRegister(Register1, Register2, DirectiveLoc); return false; } /// parseDirectiveCFIWindowSave /// ::= .cfi_window_save -bool MasmParser::parseDirectiveCFIWindowSave() { - getStreamer().emitCFIWindowSave(); +bool MasmParser::parseDirectiveCFIWindowSave(SMLoc DirectiveLoc) { + getStreamer().emitCFIWindowSave(DirectiveLoc); return false; } /// parseDirectiveCFIAdjustCfaOffset /// ::= .cfi_adjust_cfa_offset adjustment -bool MasmParser::parseDirectiveCFIAdjustCfaOffset() { +bool MasmParser::parseDirectiveCFIAdjustCfaOffset(SMLoc DirectiveLoc) { int64_t Adjustment = 0; if (parseAbsoluteExpression(Adjustment)) return true; - getStreamer().emitCFIAdjustCfaOffset(Adjustment); + getStreamer().emitCFIAdjustCfaOffset(Adjustment, DirectiveLoc); return false; } @@ -5607,7 +5607,7 @@ bool MasmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) { parseAbsoluteExpression(Offset)) return true; - getStreamer().emitCFIRelOffset(Register, Offset); + getStreamer().emitCFIRelOffset(Register, Offset, DirectiveLoc); return false; } @@ -5661,15 +5661,15 @@ bool MasmParser::parseDirectiveCFIPersonalityOrLsda(bool IsPersonality) { /// parseDirectiveCFIRememberState /// ::= .cfi_remember_state -bool MasmParser::parseDirectiveCFIRememberState() { - getStreamer().emitCFIRememberState(); +bool MasmParser::parseDirectiveCFIRememberState(SMLoc DirectiveLoc) { + getStreamer().emitCFIRememberState(DirectiveLoc); return false; } /// parseDirectiveCFIRestoreState /// ::= .cfi_remember_state -bool MasmParser::parseDirectiveCFIRestoreState() { - getStreamer().emitCFIRestoreState(); +bool MasmParser::parseDirectiveCFIRestoreState(SMLoc DirectiveLoc) { + getStreamer().emitCFIRestoreState(DirectiveLoc); return false; } @@ -5681,7 +5681,7 @@ bool MasmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) { if (parseRegisterOrRegisterNumber(Register, DirectiveLoc)) return true; - getStreamer().emitCFISameValue(Register); + getStreamer().emitCFISameValue(Register, DirectiveLoc); return false; } @@ -5698,7 +5698,7 @@ bool MasmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) { /// parseDirectiveCFIEscape /// ::= .cfi_escape expression[,...] -bool MasmParser::parseDirectiveCFIEscape() { +bool MasmParser::parseDirectiveCFIEscape(SMLoc DirectiveLoc) { std::string Values; int64_t CurrValue; if (parseAbsoluteExpression(CurrValue)) @@ -5715,7 +5715,7 @@ bool MasmParser::parseDirectiveCFIEscape() { Values.push_back((uint8_t)CurrValue); } - getStreamer().emitCFIEscape(Values); + getStreamer().emitCFIEscape(Values, DirectiveLoc); return false; } diff --git a/llvm/lib/MC/MCStreamer.cpp b/llvm/lib/MC/MCStreamer.cpp index c0e9f42406e9..e1b0fd5f1009 100644 --- a/llvm/lib/MC/MCStreamer.cpp +++ b/llvm/lib/MC/MCStreamer.cpp @@ -493,10 +493,10 @@ MCSymbol *MCStreamer::emitCFILabel() { return (MCSymbol *)1; } -void MCStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) { +void MCStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::cfiDefCfa(Label, Register, Offset); + MCCFIInstruction::cfiDefCfa(Label, Register, Offset, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; @@ -504,7 +504,7 @@ void MCStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) { CurFrame->CurrentCfaRegister = static_cast(Register); } -void MCStreamer::emitCFIDefCfaOffset(int64_t Offset) { +void MCStreamer::emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = MCCFIInstruction::cfiDefCfaOffset(Label, Offset); @@ -514,20 +514,20 @@ void MCStreamer::emitCFIDefCfaOffset(int64_t Offset) { CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment) { +void MCStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment); + MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIDefCfaRegister(int64_t Register) { +void MCStreamer::emitCFIDefCfaRegister(int64_t Register, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createDefCfaRegister(Label, Register); + MCCFIInstruction::createDefCfaRegister(Label, Register, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; @@ -536,10 +536,10 @@ void MCStreamer::emitCFIDefCfaRegister(int64_t Register) { } void MCStreamer::emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, - int64_t AddressSpace) { + int64_t AddressSpace, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = MCCFIInstruction::createLLVMDefAspaceCfa( - Label, Register, Offset, AddressSpace); + Label, Register, Offset, AddressSpace, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; @@ -547,20 +547,20 @@ void MCStreamer::emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, CurFrame->CurrentCfaRegister = static_cast(Register); } -void MCStreamer::emitCFIOffset(int64_t Register, int64_t Offset) { +void MCStreamer::emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createOffset(Label, Register, Offset); + MCCFIInstruction::createOffset(Label, Register, Offset, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset) { +void MCStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createRelOffset(Label, Register, Offset); + MCCFIInstruction::createRelOffset(Label, Register, Offset, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; @@ -584,58 +584,61 @@ void MCStreamer::emitCFILsda(const MCSymbol *Sym, unsigned Encoding) { CurFrame->LsdaEncoding = Encoding; } -void MCStreamer::emitCFIRememberState() { +void MCStreamer::emitCFIRememberState(SMLoc Loc) { MCSymbol *Label = emitCFILabel(); - MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label); + MCCFIInstruction Instruction = + MCCFIInstruction::createRememberState(Label, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIRestoreState() { +void MCStreamer::emitCFIRestoreState(SMLoc Loc) { // FIXME: Error if there is no matching cfi_remember_state. MCSymbol *Label = emitCFILabel(); - MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label); + MCCFIInstruction Instruction = + MCCFIInstruction::createRestoreState(Label, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFISameValue(int64_t Register) { +void MCStreamer::emitCFISameValue(int64_t Register, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createSameValue(Label, Register); + MCCFIInstruction::createSameValue(Label, Register, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIRestore(int64_t Register) { +void MCStreamer::emitCFIRestore(int64_t Register, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createRestore(Label, Register); + MCCFIInstruction::createRestore(Label, Register, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIEscape(StringRef Values) { - MCSymbol *Label = emitCFILabel(); - MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values); - MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); - if (!CurFrame) - return; - CurFrame->Instructions.push_back(Instruction); -} - -void MCStreamer::emitCFIGnuArgsSize(int64_t Size) { +void MCStreamer::emitCFIEscape(StringRef Values, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createGnuArgsSize(Label, Size); + MCCFIInstruction::createEscape(Label, Values, Loc, ""); + MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); + if (!CurFrame) + return; + CurFrame->Instructions.push_back(Instruction); +} + +void MCStreamer::emitCFIGnuArgsSize(int64_t Size, SMLoc Loc) { + MCSymbol *Label = emitCFILabel(); + MCCFIInstruction Instruction = + MCCFIInstruction::createGnuArgsSize(Label, Size, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; @@ -649,39 +652,40 @@ void MCStreamer::emitCFISignalFrame() { CurFrame->IsSignalFrame = true; } -void MCStreamer::emitCFIUndefined(int64_t Register) { +void MCStreamer::emitCFIUndefined(int64_t Register, SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createUndefined(Label, Register); + MCCFIInstruction::createUndefined(Label, Register, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) { +void MCStreamer::emitCFIRegister(int64_t Register1, int64_t Register2, + SMLoc Loc) { MCSymbol *Label = emitCFILabel(); MCCFIInstruction Instruction = - MCCFIInstruction::createRegister(Label, Register1, Register2); + MCCFIInstruction::createRegister(Label, Register1, Register2, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFIWindowSave() { +void MCStreamer::emitCFIWindowSave(SMLoc Loc) { MCSymbol *Label = emitCFILabel(); - MCCFIInstruction Instruction = - MCCFIInstruction::createWindowSave(Label); + MCCFIInstruction Instruction = MCCFIInstruction::createWindowSave(Label, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; CurFrame->Instructions.push_back(Instruction); } -void MCStreamer::emitCFINegateRAState() { +void MCStreamer::emitCFINegateRAState(SMLoc Loc) { MCSymbol *Label = emitCFILabel(); - MCCFIInstruction Instruction = MCCFIInstruction::createNegateRAState(Label); + MCCFIInstruction Instruction = + MCCFIInstruction::createNegateRAState(Label, Loc); MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); if (!CurFrame) return; diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp b/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp index 0310fa09c10a..d49b82290ff3 100644 --- a/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp +++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp @@ -4255,7 +4255,7 @@ static MCCFIInstruction createDefCFAExpression(const TargetRegisterInfo &TRI, uint8_t buffer[16]; DefCfaExpr.append(buffer, buffer + encodeULEB128(Expr.size(), buffer)); DefCfaExpr.append(Expr.str()); - return MCCFIInstruction::createEscape(nullptr, DefCfaExpr.str(), + return MCCFIInstruction::createEscape(nullptr, DefCfaExpr.str(), SMLoc(), Comment.str()); } @@ -4303,7 +4303,8 @@ MCCFIInstruction llvm::createCFAOffset(const TargetRegisterInfo &TRI, CfaExpr.append(buffer, buffer + encodeULEB128(OffsetExpr.size(), buffer)); CfaExpr.append(OffsetExpr.str()); - return MCCFIInstruction::createEscape(nullptr, CfaExpr.str(), Comment.str()); + return MCCFIInstruction::createEscape(nullptr, CfaExpr.str(), SMLoc(), + Comment.str()); } // Helper function to emit a frame offset adjustment from a given diff --git a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp index ebb60f83adda..159db5b70fdb 100644 --- a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp +++ b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp @@ -384,7 +384,7 @@ static MCCFIInstruction createDefCFAExpression(const TargetRegisterInfo &TRI, DefCfaExpr.append(buffer, buffer + encodeULEB128(Expr.size(), buffer)); DefCfaExpr.append(Expr.str()); - return MCCFIInstruction::createEscape(nullptr, DefCfaExpr.str(), + return MCCFIInstruction::createEscape(nullptr, DefCfaExpr.str(), SMLoc(), Comment.str()); }