mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 00:29:20 +00:00
re-commit r66920 (which has been backed out in r66953) I may have more luck this time. I'll back out if needed...
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@80858 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
9947bbb297
commit
190390b8d3
@ -2466,27 +2466,26 @@ public:
|
||||
/// indirect function invocation.
|
||||
///
|
||||
Function *getCalledFunction() const {
|
||||
return dyn_cast<Function>(getOperand(0));
|
||||
return dyn_cast<Function>(Op<-3>());
|
||||
}
|
||||
|
||||
/// getCalledValue - Get a pointer to the function that is invoked by this
|
||||
/// instruction
|
||||
const Value *getCalledValue() const { return getOperand(0); }
|
||||
Value *getCalledValue() { return getOperand(0); }
|
||||
const Value *getCalledValue() const { return Op<-3>(); }
|
||||
Value *getCalledValue() { return Op<-3>(); }
|
||||
|
||||
// get*Dest - Return the destination basic blocks...
|
||||
BasicBlock *getNormalDest() const {
|
||||
return cast<BasicBlock>(getOperand(1));
|
||||
return cast<BasicBlock>(Op<-2>());
|
||||
}
|
||||
BasicBlock *getUnwindDest() const {
|
||||
return cast<BasicBlock>(getOperand(2));
|
||||
return cast<BasicBlock>(Op<-1>());
|
||||
}
|
||||
void setNormalDest(BasicBlock *B) {
|
||||
setOperand(1, B);
|
||||
Op<-2>() = B;
|
||||
}
|
||||
|
||||
void setUnwindDest(BasicBlock *B) {
|
||||
setOperand(2, B);
|
||||
Op<-1>() = B;
|
||||
}
|
||||
|
||||
BasicBlock *getSuccessor(unsigned i) const {
|
||||
@ -2496,7 +2495,7 @@ public:
|
||||
|
||||
void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
|
||||
assert(idx < 2 && "Successor # out of range for invoke!");
|
||||
setOperand(idx+1, NewSucc);
|
||||
*(&Op<-2>() + idx) = NewSucc;
|
||||
}
|
||||
|
||||
unsigned getNumSuccessors() const { return 2; }
|
||||
@ -2509,6 +2508,7 @@ public:
|
||||
static inline bool classof(const Value *V) {
|
||||
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
||||
}
|
||||
|
||||
private:
|
||||
virtual BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
virtual unsigned getNumSuccessorsV() const;
|
||||
|
@ -118,7 +118,7 @@ public:
|
||||
///
|
||||
Value *getCalledValue() const {
|
||||
assert(getInstruction() && "Not a call or invoke instruction!");
|
||||
return getInstruction()->getOperand(0);
|
||||
return *getCallee();
|
||||
}
|
||||
|
||||
/// getCalledFunction - Return the function being called if this is a direct
|
||||
@ -132,7 +132,7 @@ public:
|
||||
///
|
||||
void setCalledFunction(Value *V) {
|
||||
assert(getInstruction() && "Not a call or invoke instruction!");
|
||||
getInstruction()->setOperand(0, V);
|
||||
*getCallee() = V;
|
||||
}
|
||||
|
||||
Value *getArgument(unsigned ArgNo) const {
|
||||
@ -146,6 +146,16 @@ public:
|
||||
getInstruction()->setOperand(getArgumentOffset() + ArgNo, newVal);
|
||||
}
|
||||
|
||||
/// Given a value use iterator, returns the argument that corresponds to it.
|
||||
/// Iterator must actually correspond to an argument.
|
||||
unsigned getArgumentNo(Value::use_iterator I) const {
|
||||
assert(getInstruction() && "Not a call or invoke instruction!");
|
||||
assert(arg_begin() <= &I.getUse() && &I.getUse() < arg_end()
|
||||
&& "Argument # out of range!");
|
||||
|
||||
return &I.getUse() - arg_begin();
|
||||
}
|
||||
|
||||
/// Given an operand number, returns the argument that corresponds to it.
|
||||
/// OperandNo must be a valid operand number that actually corresponds to an
|
||||
/// argument.
|
||||
@ -171,7 +181,7 @@ public:
|
||||
return getInstruction()->op_begin() + getArgumentOffset();
|
||||
}
|
||||
|
||||
arg_iterator arg_end() const { return getInstruction()->op_end(); }
|
||||
arg_iterator arg_end() const { return getInstruction()->op_end() - getArgumentEndOffset(); }
|
||||
bool arg_empty() const { return arg_end() == arg_begin(); }
|
||||
unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); }
|
||||
|
||||
@ -180,17 +190,25 @@ public:
|
||||
}
|
||||
|
||||
bool isCallee(Value::use_iterator UI) const {
|
||||
return getInstruction()->op_begin() == &UI.getUse();
|
||||
return getCallee() == &UI.getUse();
|
||||
}
|
||||
|
||||
private:
|
||||
/// Returns the operand number of the first argument
|
||||
unsigned getArgumentOffset() const {
|
||||
if (isCall())
|
||||
return 1; // Skip Function
|
||||
else
|
||||
return 3; // Skip Function, BB, BB
|
||||
return 0; // Args are at the front
|
||||
}
|
||||
|
||||
unsigned getArgumentEndOffset() const {
|
||||
if (isCall())
|
||||
return 0; // Unchanged
|
||||
else
|
||||
return 3; // Skip BB, BB, Function
|
||||
}
|
||||
|
||||
User::op_iterator getCallee() const;
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
|
@ -1018,7 +1018,7 @@ bool Andersens::AnalyzeUsesOfFunction(Value *V) {
|
||||
} else if (InvokeInst *II = dyn_cast<InvokeInst>(*UI)) {
|
||||
// Make sure that this is just the function being called, not that it is
|
||||
// passing into the function.
|
||||
for (unsigned i = 3, e = II->getNumOperands(); i != e; ++i)
|
||||
for (unsigned i = 0, e = II->getNumOperands() - 3; i != e; ++i)
|
||||
if (II->getOperand(i) == V) return true;
|
||||
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(*UI)) {
|
||||
if (CE->getOpcode() == Instruction::GetElementPtr ||
|
||||
|
@ -244,7 +244,7 @@ bool GlobalsModRef::AnalyzeUsesOfPointer(Value *V,
|
||||
} else if (InvokeInst *II = dyn_cast<InvokeInst>(*UI)) {
|
||||
// Make sure that this is just the function being called, not that it is
|
||||
// passing into the function.
|
||||
for (unsigned i = 3, e = II->getNumOperands(); i != e; ++i)
|
||||
for (unsigned i = 0, e = II->getNumOperands() - 3; i != e; ++i)
|
||||
if (II->getOperand(i) == V) return true;
|
||||
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(*UI)) {
|
||||
if (CE->getOpcode() == Instruction::GetElementPtr ||
|
||||
|
@ -960,11 +960,11 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
|
||||
|
||||
// Emit value #'s for the fixed parameters.
|
||||
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
||||
Vals.push_back(VE.getValueID(I.getOperand(i+3))); // fixed param.
|
||||
Vals.push_back(VE.getValueID(I.getOperand(i))); // fixed param.
|
||||
|
||||
// Emit type/value pairs for varargs params.
|
||||
if (FTy->isVarArg()) {
|
||||
for (unsigned i = 3+FTy->getNumParams(), e = I.getNumOperands();
|
||||
for (unsigned i = FTy->getNumParams(), e = I.getNumOperands()-3;
|
||||
i != e; ++i)
|
||||
PushValueAndType(I.getOperand(i), InstID, Vals, VE); // vararg
|
||||
}
|
||||
|
@ -353,14 +353,14 @@ DAE::Liveness DAE::SurveyUse(Value::use_iterator U, UseVector &MaybeLiveUses,
|
||||
// argument, since if it was the function argument this would be an
|
||||
// indirect call and the we know can't be looking at a value of the
|
||||
// label type (for the invoke instruction).
|
||||
unsigned ArgNo = CS.getArgumentNo(U.getOperandNo());
|
||||
unsigned ArgNo = CS.getArgumentNo(U);
|
||||
|
||||
if (ArgNo >= F->getFunctionType()->getNumParams())
|
||||
// The value is passed in through a vararg! Must be live.
|
||||
return Live;
|
||||
|
||||
assert(CS.getArgument(ArgNo)
|
||||
== CS.getInstruction()->getOperand(U.getOperandNo())
|
||||
assert(CS.getArgument(ArgNo)
|
||||
== CS.getInstruction()->getOperand(U.getOperandNo())
|
||||
&& "Argument is not where we expected it");
|
||||
|
||||
// Value passed to a normal call. It's only live when the corresponding
|
||||
|
@ -169,7 +169,7 @@ bool PruneEH::SimplifyFunction(Function *F) {
|
||||
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
|
||||
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator()))
|
||||
if (II->doesNotThrow()) {
|
||||
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
|
||||
SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3);
|
||||
// Insert a call instruction before the invoke.
|
||||
CallInst *Call = CallInst::Create(II->getCalledValue(),
|
||||
Args.begin(), Args.end(), "", II);
|
||||
|
@ -78,7 +78,7 @@ static void ChangeToUnreachable(Instruction *I, LLVMContext &Context) {
|
||||
/// ChangeToCall - Convert the specified invoke into a normal call.
|
||||
static void ChangeToCall(InvokeInst *II) {
|
||||
BasicBlock *BB = II->getParent();
|
||||
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
|
||||
SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3);
|
||||
CallInst *NewCall = CallInst::Create(II->getCalledValue(), Args.begin(),
|
||||
Args.end(), "", II);
|
||||
NewCall->takeName(II);
|
||||
|
@ -228,7 +228,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) {
|
||||
bool Changed = false;
|
||||
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
||||
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
|
||||
std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
|
||||
std::vector<Value*> CallArgs(II->op_begin(), II->op_end() - 3);
|
||||
// Insert a normal call instruction...
|
||||
CallInst *NewCall = CallInst::Create(II->getCalledValue(),
|
||||
CallArgs.begin(), CallArgs.end(), "",II);
|
||||
@ -300,7 +300,7 @@ void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo,
|
||||
CatchSwitch->addCase(InvokeNoC, II->getUnwindDest());
|
||||
|
||||
// Insert a normal call instruction.
|
||||
std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
|
||||
std::vector<Value*> CallArgs(II->op_begin(), II->op_end() - 3);
|
||||
CallInst *NewCall = CallInst::Create(II->getCalledValue(),
|
||||
CallArgs.begin(), CallArgs.end(), "",
|
||||
II);
|
||||
|
@ -1863,6 +1863,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
|
||||
if (PAL.getFnAttributes() != Attribute::None)
|
||||
Out << ' ' << Attribute::getAsString(PAL.getFnAttributes());
|
||||
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
|
||||
Operand = II->getCalledValue();
|
||||
const PointerType *PTy = cast<PointerType>(Operand->getType());
|
||||
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
||||
const Type *RetTy = FTy->getReturnType();
|
||||
@ -1899,10 +1900,10 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
|
||||
writeOperand(Operand, true);
|
||||
}
|
||||
Out << '(';
|
||||
for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
|
||||
if (op > 3)
|
||||
for (unsigned op = 0, Eop = I.getNumOperands() - 3; op < Eop; ++op) {
|
||||
if (op)
|
||||
Out << ", ";
|
||||
writeParamOperand(I.getOperand(op), PAL.getParamAttributes(op-2));
|
||||
writeParamOperand(I.getOperand(op), PAL.getParamAttributes(op + 1));
|
||||
}
|
||||
|
||||
Out << ')';
|
||||
|
@ -95,6 +95,13 @@ bool CallSite::hasArgument(const Value *Arg) const {
|
||||
return false;
|
||||
}
|
||||
|
||||
User::op_iterator CallSite::getCallee() const {
|
||||
Instruction *II(getInstruction());
|
||||
return isCall()
|
||||
? cast<CallInst>(II)->op_begin()
|
||||
: cast<InvokeInst>(II)->op_end() - 3; // Skip BB, BB, Function
|
||||
}
|
||||
|
||||
#undef CALLSITE_DELEGATE_GETTER
|
||||
#undef CALLSITE_DELEGATE_SETTER
|
||||
|
||||
@ -435,10 +442,9 @@ bool CallInst::paramHasAttr(unsigned i, Attributes attr) const {
|
||||
void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
|
||||
Value* const *Args, unsigned NumArgs) {
|
||||
assert(NumOperands == 3+NumArgs && "NumOperands not set up?");
|
||||
Use *OL = OperandList;
|
||||
OL[0] = Fn;
|
||||
OL[1] = IfNormal;
|
||||
OL[2] = IfException;
|
||||
Op<-3>() = Fn;
|
||||
Op<-2>() = IfNormal;
|
||||
Op<-1>() = IfException;
|
||||
const FunctionType *FTy =
|
||||
cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType());
|
||||
FTy = FTy; // silence warning.
|
||||
@ -447,12 +453,13 @@ void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
|
||||
(FTy->isVarArg() && NumArgs > FTy->getNumParams())) &&
|
||||
"Calling a function with bad signature");
|
||||
|
||||
Use *OL = OperandList;
|
||||
for (unsigned i = 0, e = NumArgs; i != e; i++) {
|
||||
assert((i >= FTy->getNumParams() ||
|
||||
FTy->getParamType(i) == Args[i]->getType()) &&
|
||||
"Invoking a function with a bad signature!");
|
||||
|
||||
OL[i+3] = Args[i];
|
||||
OL[i] = Args[i];
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1412,7 +1412,7 @@ void Verifier::visitInstruction(Instruction &I) {
|
||||
"Instruction does not dominate all uses!", Op, &I);
|
||||
}
|
||||
} else if (isa<InlineAsm>(I.getOperand(i))) {
|
||||
Assert1(i == 0 && (isa<CallInst>(I) || isa<InvokeInst>(I)),
|
||||
Assert1((i == 0 && isa<CallInst>(I)) || (i + 3 == e && isa<InvokeInst>(I)),
|
||||
"Cannot take the address of an inline asm!", &I);
|
||||
}
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user