maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

MC: make MCWin64EHInstruction a POD-like struct 

This is the first of a number of changes designed to generalise
MCWin64EHInstruction to support different target architectures.  An ordered set
(vector) of these instructions is saved per frame to permit the emission of
information for Windows NT style unwinding.  The only bit of information which
is actually target specific here is the Opcode for the unwinding bytecode.  The
remainder of the information is simply generic information that is relevant to
the Windows NT unwinding model.

Remove the accessors for the fields, making them const and public instead.  Sink
the knowledge of the alias'ed name into the single source and sink a single-use
check method into the use.

llvm-svn: 212914
This commit is contained in:
Saleem Abdulrasool 2014-07-13 19:03:45 +00:00
parent 5705cd8cf6
commit c7c3cb1f4e
2 changed files with 57 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
llvm/include/llvm/MC/MCWin64EH.h
View File

@ -24,41 +24,37 @@ namespace llvm {
class MCStreamer;
class MCSymbol;
class MCWin64EHInstruction {
public:
typedef Win64EH::UnwindOpcodes OpType;
private:
OpType Operation;
MCSymbol *Label;
unsigned Offset;
unsigned Register;
public:
MCWin64EHInstruction(OpType Op, MCSymbol *L, unsigned Reg)
struct MCWin64EHInstruction {
typedef Win64EH::UnwindOpcodes OpType;
const OpType Operation;
const MCSymbol *Label;
const unsigned Offset;
const unsigned Register;
MCWin64EHInstruction(OpType Op, MCSymbol *L, unsigned Reg)
: Operation(Op), Label(L), Offset(0), Register(Reg) {
assert(Op == Win64EH::UOP_PushNonVol);
}
MCWin64EHInstruction(MCSymbol *L, unsigned Size)
: Operation(Size>128 ? Win64EH::UOP_AllocLarge : Win64EH::UOP_AllocSmall),
Label(L), Offset(Size) { }
MCWin64EHInstruction(OpType Op, MCSymbol *L, unsigned Reg, unsigned Off)
assert(Op == Win64EH::UOP_PushNonVol);
}
MCWin64EHInstruction(MCSymbol *L, unsigned Size)
: Operation(Size > 128 ? Win64EH::UOP_AllocLarge
: Win64EH::UOP_AllocSmall),
Label(L), Offset(Size), Register(-1) {}
MCWin64EHInstruction(OpType Op, MCSymbol *L, unsigned Reg, unsigned Off)
: Operation(Op), Label(L), Offset(Off), Register(Reg) {
assert(Op == Win64EH::UOP_SetFPReg ||
Op == Win64EH::UOP_SaveNonVol ||
Op == Win64EH::UOP_SaveNonVolBig ||
Op == Win64EH::UOP_SaveXMM128 ||
Op == Win64EH::UOP_SaveXMM128Big);
}
MCWin64EHInstruction(OpType Op, MCSymbol *L, bool Code)
: Operation(Op), Label(L), Offset(Code ? 1 : 0) {
assert(Op == Win64EH::UOP_PushMachFrame);
}
OpType getOperation() const { return Operation; }
MCSymbol *getLabel() const { return Label; }
unsigned getOffset() const { return Offset; }
unsigned getSize() const { return Offset; }
unsigned getRegister() const { return Register; }
bool isPushCodeFrame() const { return Offset == 1; }
};
assert(Op == Win64EH::UOP_SetFPReg ||
Op == Win64EH::UOP_SaveNonVol ||
Op == Win64EH::UOP_SaveNonVolBig ||
Op == Win64EH::UOP_SaveXMM128 ||
Op == Win64EH::UOP_SaveXMM128Big);
}
MCWin64EHInstruction(OpType Op, MCSymbol *L, bool Code)
: Operation(Op), Label(L), Offset(Code ? 1 : 0), Register(-1) {
assert(Op == Win64EH::UOP_PushMachFrame);
}
};
struct MCWinFrameInfo {
MCWinFrameInfo()

57
llvm/lib/MC/MCWin64EH.cpp
View File

@ -23,7 +23,7 @@ namespace llvm {
static uint8_t CountOfUnwindCodes(std::vector<MCWin64EHInstruction> &Insns) {
uint8_t Count = 0;
for (const auto &I : Insns) {
switch (I.getOperation()) {
switch (I.Operation) {
case Win64EH::UOP_PushNonVol:
case Win64EH::UOP_AllocSmall:
case Win64EH::UOP_SetFPReg:
@ -39,7 +39,7 @@ static uint8_t CountOfUnwindCodes(std::vector<MCWin64EHInstruction> &Insns) {
Count += 3;
break;
case Win64EH::UOP_AllocLarge:
Count += (I.getSize() > 512 * 1024 - 8) ? 3 : 2;
Count += (I.Offset > 512 * 1024 - 8) ? 3 : 2;
break;
}
}
@ -59,63 +59,63 @@ static void EmitUnwindCode(MCStreamer &streamer, MCSymbol *begin,
MCWin64EHInstruction &inst) {
uint8_t b2;
uint16_t w;
b2 = (inst.getOperation() & 0x0F);
switch (inst.getOperation()) {
b2 = (inst.Operation & 0x0F);
switch (inst.Operation) {
case Win64EH::UOP_PushNonVol:
EmitAbsDifference(streamer, inst.getLabel(), begin);
b2 |= (inst.getRegister() & 0x0F) << 4;
EmitAbsDifference(streamer, inst.Label, begin);
b2 |= (inst.Register & 0x0F) << 4;
streamer.EmitIntValue(b2, 1);
break;
case Win64EH::UOP_AllocLarge:
EmitAbsDifference(streamer, inst.getLabel(), begin);
if (inst.getSize() > 512*1024-8) {
EmitAbsDifference(streamer, inst.Label, begin);
if (inst.Offset > 512 * 1024 - 8) {
b2 |= 0x10;
streamer.EmitIntValue(b2, 1);
w = inst.getSize() & 0xFFF8;
w = inst.Offset & 0xFFF8;
streamer.EmitIntValue(w, 2);
w = inst.getSize() >> 16;
w = inst.Offset >> 16;
} else {
streamer.EmitIntValue(b2, 1);
w = inst.getSize() >> 3;
w = inst.Offset >> 3;
}
streamer.EmitIntValue(w, 2);
break;
case Win64EH::UOP_AllocSmall:
b2 |= (((inst.getSize()-8) >> 3) & 0x0F) << 4;
EmitAbsDifference(streamer, inst.getLabel(), begin);
b2 |= (((inst.Offset - 8) >> 3) & 0x0F) << 4;
EmitAbsDifference(streamer, inst.Label, begin);
streamer.EmitIntValue(b2, 1);
break;
case Win64EH::UOP_SetFPReg:
EmitAbsDifference(streamer, inst.getLabel(), begin);
EmitAbsDifference(streamer, inst.Label, begin);
streamer.EmitIntValue(b2, 1);
break;
case Win64EH::UOP_SaveNonVol:
case Win64EH::UOP_SaveXMM128:
b2 |= (inst.getRegister() & 0x0F) << 4;
EmitAbsDifference(streamer, inst.getLabel(), begin);
b2 |= (inst.Register & 0x0F) << 4;
EmitAbsDifference(streamer, inst.Label, begin);
streamer.EmitIntValue(b2, 1);
w = inst.getOffset() >> 3;
if (inst.getOperation() == Win64EH::UOP_SaveXMM128)
w = inst.Offset >> 3;
if (inst.Operation == Win64EH::UOP_SaveXMM128)
w >>= 1;
streamer.EmitIntValue(w, 2);
break;
case Win64EH::UOP_SaveNonVolBig:
case Win64EH::UOP_SaveXMM128Big:
b2 |= (inst.getRegister() & 0x0F) << 4;
EmitAbsDifference(streamer, inst.getLabel(), begin);
b2 |= (inst.Register & 0x0F) << 4;
EmitAbsDifference(streamer, inst.Label, begin);
streamer.EmitIntValue(b2, 1);
if (inst.getOperation() == Win64EH::UOP_SaveXMM128Big)
w = inst.getOffset() & 0xFFF0;
if (inst.Operation == Win64EH::UOP_SaveXMM128Big)
w = inst.Offset & 0xFFF0;
else
w = inst.getOffset() & 0xFFF8;
w = inst.Offset & 0xFFF8;
streamer.EmitIntValue(w, 2);
w = inst.getOffset() >> 16;
w = inst.Offset >> 16;
streamer.EmitIntValue(w, 2);
break;
case Win64EH::UOP_PushMachFrame:
if (inst.isPushCodeFrame())
if (inst.Offset == 1)
b2 |= 0x10;
EmitAbsDifference(streamer, inst.getLabel(), begin);
EmitAbsDifference(streamer, inst.Label, begin);
streamer.EmitIntValue(b2, 1);
break;
}
@ -178,9 +178,8 @@ static void EmitUnwindInfo(MCStreamer &streamer, MCWinFrameInfo *info) {
uint8_t frame = 0;
if (info->LastFrameInst >= 0) {
MCWin64EHInstruction &frameInst = info->Instructions[info->LastFrameInst];
assert(frameInst.getOperation() == Win64EH::UOP_SetFPReg);
frame = (frameInst.getRegister() & 0x0F) |
(frameInst.getOffset() & 0xF0);
assert(frameInst.Operation == Win64EH::UOP_SetFPReg);
frame = (frameInst.Register & 0x0F) | (frameInst.Offset & 0xF0);
}
streamer.EmitIntValue(frame, 1);