[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.
This commit is contained in:
Fangrui Song
parent
2c1108f443
commit
665ccc19d3
@ -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 @@ private:
|
||||
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 @@ 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 {
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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());
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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));
|
||||
|
||||
@ -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();
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
@ -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) {
|
||||
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;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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());
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user