[llvm] 665ccc1 - [MC] Add SMLoc to MCCFIInstruction
Fangrui Song via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 26 17:58:32 PDT 2023
Author: Fangrui Song
Date: 2023-06-26T17:58:29-07:00
New Revision: 665ccc19d38ccee9bba869ec9706610cefb10b0c
URL: https://github.com/llvm/llvm-project/commit/665ccc19d38ccee9bba869ec9706610cefb10b0c
DIFF: https://github.com/llvm/llvm-project/commit/665ccc19d38ccee9bba869ec9706610cefb10b0c.diff
LOG: [MC] Add SMLoc to MCCFIInstruction
to help debug and report better diagnostics for functions like
relaxDwarfCallFrameFragment (D153167).
In MCStreamer, some emitCFI* functions already take a SMLoc argument. Add a
SMLoc argument to the remaining functions that generate a MCCFIInstruction.
Added:
Modified:
llvm/include/llvm/MC/MCDwarf.h
llvm/include/llvm/MC/MCObjectStreamer.h
llvm/include/llvm/MC/MCStreamer.h
llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
llvm/lib/CodeGen/MIRParser/MIParser.cpp
llvm/lib/MC/MCAsmStreamer.cpp
llvm/lib/MC/MCDwarf.cpp
llvm/lib/MC/MCObjectStreamer.cpp
llvm/lib/MC/MCParser/AsmParser.cpp
llvm/lib/MC/MCParser/MasmParser.cpp
llvm/lib/MC/MCStreamer.cpp
llvm/lib/Target/AArch64/AArch64InstrInfo.cpp
llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/MC/MCDwarf.h b/llvm/include/llvm/MC/MCDwarf.h
index 547fb34a06969..7dc1c383bbf3f 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 <cassert>
#include <cstdint>
@@ -39,7 +40,6 @@ class MCSection;
class MCStreamer;
class MCSymbol;
class raw_ostream;
-class SMLoc;
class SourceMgr;
namespace mcdwarf {
@@ -507,52 +507,58 @@ class MCCFIInstruction {
unsigned Register2;
};
unsigned AddressSpace = ~0u;
+ SMLoc Loc;
std::vector<char> 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 @@ class MCCFIInstruction {
/// `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 @@ class MCCFIInstruction {
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 865b914f88c9b..5e5b4b3150170 100644
--- a/llvm/include/llvm/MC/MCObjectStreamer.h
+++ b/llvm/include/llvm/MC/MCObjectStreamer.h
@@ -168,7 +168,7 @@ class MCObjectStreamer : public MCStreamer {
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 8b081db4dedd1..5f12fcc1c840b 100644
--- a/llvm/include/llvm/MC/MCStreamer.h
+++ b/llvm/include/llvm/MC/MCStreamer.h
@@ -1025,28 +1025,29 @@ class MCStreamer {
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 1d5ddef173383..21d0d070c247f 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 f2df73ef3f205..bfd9286ff59c0 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 de48c9e965f14..78950ed0b095d 100644
--- a/llvm/lib/MC/MCAsmStreamer.cpp
+++ b/llvm/lib/MC/MCAsmStreamer.cpp
@@ -328,27 +328,28 @@ class MCAsmStreamer final : public MCStreamer {
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 9506b5cd59297..4d21098553fe5 100644
--- a/llvm/lib/MC/MCDwarf.cpp
+++ b/llvm/lib/MC/MCDwarf.cpp
@@ -1476,7 +1476,7 @@ void FrameEmitterImpl::emitCFIInstructions(ArrayRef<MCCFIInstruction> 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 64fbe618b57f2..9398eb85618aa 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 7f0f316b33820..2c81c33c92d53 100644
--- a/llvm/lib/MC/MCParser/AsmParser.cpp
+++ b/llvm/lib/MC/MCParser/AsmParser.cpp
@@ -601,25 +601,25 @@ class AsmParser : public MCAsmParser {
// .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 d522b77c25874..d41df71edbdfa 100644
--- a/llvm/lib/MC/MCParser/MasmParser.cpp
+++ b/llvm/lib/MC/MCParser/MasmParser.cpp
@@ -962,22 +962,22 @@ class MasmParser : public MCAsmParser {
// .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 c0e9f42406e9b..e1b0fd5f1009e 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<unsigned>(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<unsigned>(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) {
+void MCStreamer::emitCFIEscape(StringRef Values, SMLoc Loc) {
MCSymbol *Label = emitCFILabel();
- MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
+ MCCFIInstruction Instruction =
+ MCCFIInstruction::createEscape(Label, Values, Loc, "");
MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
if (!CurFrame)
return;
CurFrame->Instructions.push_back(Instruction);
}
-void MCStreamer::emitCFIGnuArgsSize(int64_t Size) {
+void MCStreamer::emitCFIGnuArgsSize(int64_t Size, SMLoc Loc) {
MCSymbol *Label = emitCFILabel();
MCCFIInstruction Instruction =
- MCCFIInstruction::createGnuArgsSize(Label, Size);
+ 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 0310fa09c10a8..d49b82290ff3b 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 ebb60f83addac..159db5b70fdbe 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());
}
More information about the llvm-commits
mailing list