6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2026-04-20 16:17:38 +00:00
Code Issues Projects Releases Wiki Activity

New EH representation for MSVC compatibility

Browse Source 
Summary:
This introduces new instructions neccessary to implement MSVC-compatible
exception handling support.  Most of the middle-end and none of the
back-end haven't been audited or updated to take them into account.

Reviewers: rnk, JosephTremoulet, reames, nlewycky, rjmccall

Subscribers: llvm-commits

Differential Revision: http://reviews.llvm.org/D11041

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241888 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Majnemer
2015-07-10 07:00:44 +00:00
parent 86ef198476
commit 751c4be705
35 changed files with 2042 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/Bitcode/Reader/BitcodeReader.cpp
+128
View File
@@ -3793,6 +3793,134 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) {
}
break;
}
// CLEANUPRET: [] or [ty,val] or [bb#] or [ty,val,bb#]
case bitc::FUNC_CODE_INST_CLEANUPRET: {
if (Record.size() < 2)
return error("Invalid record");
unsigned Idx = 0;
bool HasReturnValue = !!Record[Idx++];
bool HasUnwindDest = !!Record[Idx++];
Value *RetVal = nullptr;
BasicBlock *UnwindDest = nullptr;
if (HasReturnValue && getValueTypePair(Record, Idx, NextValueNo, RetVal))
return error("Invalid record");
if (HasUnwindDest) {
if (Idx == Record.size())
return error("Invalid record");
UnwindDest = getBasicBlock(Record[Idx++]);
if (!UnwindDest)
return error("Invalid record");
}
if (Record.size() != Idx)
return error("Invalid record");
I = CleanupReturnInst::Create(Context, RetVal, UnwindDest);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [bb#]
if (Record.size() != 1)
return error("Invalid record");
BasicBlock *BB = getBasicBlock(Record[0]);
if (!BB)
return error("Invalid record");
I = CatchReturnInst::Create(BB);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_CATCHBLOCK: { // CATCHBLOCK: [ty,bb#,bb#,num,(ty,val)*]
if (Record.size() < 4)
return error("Invalid record");
unsigned Idx = 0;
Type *Ty = getTypeByID(Record[Idx++]);
if (!Ty)
return error("Invalid record");
BasicBlock *NormalBB = getBasicBlock(Record[Idx++]);
if (!NormalBB)
return error("Invalid record");
BasicBlock *UnwindBB = getBasicBlock(Record[Idx++]);
if (!UnwindBB)
return error("Invalid record");
unsigned NumArgOperands = Record[Idx++];
SmallVector<Value *, 2> Args;
for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
Value *Val;
if (getValueTypePair(Record, Idx, NextValueNo, Val))
return error("Invalid record");
Args.push_back(Val);
}
if (Record.size() != Idx)
return error("Invalid record");
I = CatchBlockInst::Create(Ty, NormalBB, UnwindBB, Args);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_TERMINATEBLOCK: { // TERMINATEBLOCK: [bb#,num,(ty,val)*]
if (Record.size() < 1)
return error("Invalid record");
unsigned Idx = 0;
bool HasUnwindDest = !!Record[Idx++];
BasicBlock *UnwindDest = nullptr;
if (HasUnwindDest) {
if (Idx == Record.size())
return error("Invalid record");
UnwindDest = getBasicBlock(Record[Idx++]);
if (!UnwindDest)
return error("Invalid record");
}
unsigned NumArgOperands = Record[Idx++];
SmallVector<Value *, 2> Args;
for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
Value *Val;
if (getValueTypePair(Record, Idx, NextValueNo, Val))
return error("Invalid record");
Args.push_back(Val);
}
if (Record.size() != Idx)
return error("Invalid record");
I = TerminateBlockInst::Create(Context, UnwindDest, Args);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_CLEANUPBLOCK: { // CLEANUPBLOCK: [ty, num,(ty,val)*]
if (Record.size() < 2)
return error("Invalid record");
unsigned Idx = 0;
Type *Ty = getTypeByID(Record[Idx++]);
if (!Ty)
return error("Invalid record");
unsigned NumArgOperands = Record[Idx++];
SmallVector<Value *, 2> Args;
for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
Value *Val;
if (getValueTypePair(Record, Idx, NextValueNo, Val))
return error("Invalid record");
Args.push_back(Val);
}
if (Record.size() != Idx)
return error("Invalid record");
I = CleanupBlockInst::Create(Ty, Args);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_CATCHENDBLOCK: { // CATCHENDBLOCKINST: [bb#] or []
if (Record.size() > 1)
return error("Invalid record");
BasicBlock *BB = nullptr;
if (Record.size() == 1) {
BB = getBasicBlock(Record[0]);
if (!BB)
return error("Invalid record");
}
I = CatchEndBlockInst::Create(Context, BB);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
// Check magic
if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
lib/Bitcode/Writer/BitcodeWriter.cpp
+58
View File
@@ -1845,6 +1845,64 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
Code = bitc::FUNC_CODE_INST_RESUME;
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
break;
case Instruction::CleanupRet: {
Code = bitc::FUNC_CODE_INST_CLEANUPRET;
const auto &CRI = cast<CleanupReturnInst>(I);
Vals.push_back(CRI.hasReturnValue());
Vals.push_back(CRI.hasUnwindDest());
if (CRI.hasReturnValue())
PushValueAndType(CRI.getReturnValue(), InstID, Vals, VE);
if (CRI.hasUnwindDest())
Vals.push_back(VE.getValueID(CRI.getUnwindDest()));
break;
}
case Instruction::CatchRet: {
Code = bitc::FUNC_CODE_INST_CATCHRET;
const auto &CRI = cast<CatchReturnInst>(I);
Vals.push_back(VE.getValueID(CRI.getSuccessor()));
break;
}
case Instruction::CatchBlock: {
Code = bitc::FUNC_CODE_INST_CATCHBLOCK;
const auto &CBI = cast<CatchBlockInst>(I);
Vals.push_back(VE.getTypeID(CBI.getType()));
Vals.push_back(VE.getValueID(CBI.getNormalDest()));
Vals.push_back(VE.getValueID(CBI.getUnwindDest()));
unsigned NumArgOperands = CBI.getNumArgOperands();
Vals.push_back(NumArgOperands);
for (unsigned Op = 0; Op != NumArgOperands; ++Op)
PushValueAndType(CBI.getArgOperand(Op), InstID, Vals, VE);
break;
}
case Instruction::TerminateBlock: {
Code = bitc::FUNC_CODE_INST_TERMINATEBLOCK;
const auto &TBI = cast<TerminateBlockInst>(I);
Vals.push_back(TBI.hasUnwindDest());
if (TBI.hasUnwindDest())
Vals.push_back(VE.getValueID(TBI.getUnwindDest()));
unsigned NumArgOperands = TBI.getNumArgOperands();
Vals.push_back(NumArgOperands);
for (unsigned Op = 0; Op != NumArgOperands; ++Op)
PushValueAndType(TBI.getArgOperand(Op), InstID, Vals, VE);
break;
}
case Instruction::CleanupBlock: {
Code = bitc::FUNC_CODE_INST_CLEANUPBLOCK;
const auto &CBI = cast<CleanupBlockInst>(I);
Vals.push_back(VE.getTypeID(CBI.getType()));
unsigned NumOperands = CBI.getNumOperands();
Vals.push_back(NumOperands);
for (unsigned Op = 0; Op != NumOperands; ++Op)
PushValueAndType(CBI.getOperand(Op), InstID, Vals, VE);
break;
}
case Instruction::CatchEndBlock: {
Code = bitc::FUNC_CODE_INST_CATCHENDBLOCK;
const auto &CEBI = cast<CatchEndBlockInst>(I);
if (CEBI.hasUnwindDest())
Vals.push_back(VE.getValueID(CEBI.getUnwindDest()));
break;
}
case Instruction::Unreachable:
Code = bitc::FUNC_CODE_INST_UNREACHABLE;
AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;