6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-14 00:31:06 +00:00
Code Issues Projects Releases Wiki Activity

New CallInst interface to address GLIBCXX_DEBUG errors caused by

Browse Source 
indexing an empty std::vector.

Updates to all clients.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40660 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Greene 2007-08-01 03:43:44 +00:00
parent 7fc77611ef
commit 52eec54820
22 changed files with 158 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
include/llvm/Instructions.h
View File

@ -16,7 +16,10 @@
#ifndef LLVM_INSTRUCTIONS_H
#define LLVM_INSTRUCTIONS_H
#include <iterator>
#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
namespace llvm {
@ -735,12 +738,12 @@ public:
//===----------------------------------------------------------------------===//
// CallInst Class
//===----------------------------------------------------------------------===//
/// CallInst - This class represents a function call, abstracting a target
/// machine's calling convention. This class uses low bit of the SubClassData
/// field to indicate whether or not this is a tail call. The rest of the bits
/// hold the calling convention of the call.
///
class CallInst : public Instruction {
ParamAttrsList *ParamAttrs; ///< parameter attributes for call
CallInst(const CallInst &CI);
@ -749,18 +752,73 @@ class CallInst : public Instruction {
void init(Value *Func, Value *Actual);
void init(Value *Func);
template<typename InputIterator>
void init(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
const std::string &Name,
// This argument ensures that we have an iterator we can
// do arithmetic on in constant time
std::random_access_iterator_tag) {
typename std::iterator_traits<InputIterator>::difference_type NumArgs =
std::distance(ArgBegin, ArgEnd);
if (NumArgs > 0) {
// This requires that the iterator points to contiguous memory.
init(Func, &*ArgBegin, NumArgs);
}
else {
init(Func, 0, NumArgs);
}
setName(Name);
}
public:
/// Construct a CallInst given a range of arguments. InputIterator
/// must be a random-access iterator pointing to contiguous storage
/// (e.g. a std::vector<>::iterator). Checks are made for
/// random-accessness but not for contiguous storage as that would
/// incur runtime overhead.
/// @brief Construct a CallInst from a range of arguments
template<typename InputIterator>
CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
const std::string &Name = "", Instruction *InsertBefore = 0)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
->getElementType())->getReturnType(),
Instruction::Call, 0, 0, InsertBefore) {
init(Func, ArgBegin, ArgEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());
}
/// Construct a CallInst given a range of arguments. InputIterator
/// must be a random-access iterator pointing to contiguous storage
/// (e.g. a std::vector<>::iterator). Checks are made for
/// random-accessness but not for contiguous storage as that would
/// incur runtime overhead.
/// @brief Construct a CallInst from a range of arguments
template<typename InputIterator>
CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
const std::string &Name, BasicBlock *InsertAtEnd)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
->getElementType())->getReturnType(),
Instruction::Call, 0, 0, InsertAtEnd) {
init(Func, ArgBegin, ArgEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());
}
#if 0
// Leave these here for llvm-gcc
CallInst(Value *F, Value* const *Args, unsigned NumArgs,
const std::string &Name = "", Instruction *InsertBefore = 0);
CallInst(Value *F, Value *const *Args, unsigned NumArgs,
const std::string &Name, BasicBlock *InsertAtEnd);
// Alternate CallInst ctors w/ two actuals, w/ one actual and no
// actuals, respectively.
CallInst(Value *F, Value *Actual1, Value *Actual2,
const std::string& Name = "", Instruction *InsertBefore = 0);
CallInst(Value *F, Value *Actual1, Value *Actual2,
const std::string& Name, BasicBlock *InsertAtEnd);
#endif
CallInst(Value *F, Value *Actual, const std::string& Name = "",
Instruction *InsertBefore = 0);
CallInst(Value *F, Value *Actual, const std::string& Name,

23
include/llvm/Support/LLVMBuilder.h
View File

@ -380,22 +380,31 @@ public:
}
CallInst *CreateCall(Value *Callee, const char *Name = "") {
return Insert(new CallInst(Callee, (Value**)0, 0, Name));
return Insert(new CallInst(Callee, Name));
}
CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
return Insert(new CallInst(Callee, &Arg, 1, Name));
return Insert(new CallInst(Callee, Arg, Name));
}
CallInst *CreateCall(Value *Callee, Value *Arg0, Value *Arg1,
template<typename InputIterator>
CallInst *CreateCall(Value *Callee, InputIterator ArgBegin, InputIterator ArgEnd,
const char *Name = "") {
Value *Args[] = { Arg0, Arg1 };
return Insert(new CallInst(Callee, Args, 2, Name));
return(Insert(new CallInst(Callee, ArgBegin, ArgEnd, Name)));
}
#if 0
CallInst *CreateCall(Value *Callee, Value *Arg0, Value *Arg1,
const char *Name = "") {
Value *Args[] = { Arg0, Arg1 };
return Insert(new CallInst(Callee, Args, Args+2, Name));
}
// Leave this here for llvm-gcc
CallInst *CreateCall(Value *Callee, Value* const *Args, unsigned NumArgs,
const char *Name = "") {
return Insert(new CallInst(Callee, Args, NumArgs, Name));
return Insert(new CallInst(Callee, Args, Args+NumArgs, Name));
}
#endif
SelectInst *CreateSelect(Value *C, Value *True, Value *False,
const char *Name = "") {

2
lib/AsmParser/llvmAsmParser.y
View File

@ -2958,7 +2958,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
GEN_ERROR("Invalid number of parameters detected");
}
// Create the call node
CallInst *CI = new CallInst(V, &Args[0], Args.size());
CallInst *CI = new CallInst(V, Args.begin(), Args.end());
CI->setTailCall($1);
CI->setCallingConv($2);
$$ = CI;

2
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -1499,7 +1499,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
}
}
I = new CallInst(Callee, &Args[0], Args.size());
I = new CallInst(Callee, Args.begin(), Args.end());
cast<CallInst>(I)->setCallingConv(CCInfo>>1);
cast<CallInst>(I)->setTailCall(CCInfo & 1);
break;

8
lib/CodeGen/IntrinsicLowering.cpp
View File

@ -53,8 +53,8 @@ static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
FunctionType::get(RetTy, ParamTys, false));
}
SmallVector<Value*, 8> Operands(ArgBegin, ArgEnd);
CallInst *NewCI = new CallInst(FCache, &Operands[0], Operands.size(),
SmallVector<Value *, 8> Args(ArgBegin, ArgEnd);
CallInst *NewCI = new CallInst(FCache, Args.begin(), Args.end(),
CI->getName(), CI);
if (!CI->use_empty())
CI->replaceAllUsesWith(NewCI);
@ -421,7 +421,7 @@ static Instruction *LowerPartSelect(CallInst *CI) {
CI->getOperand(2),
CI->getOperand(3)
};
return new CallInst(F, Args, sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
}
/// Convert the llvm.part.set.iX.iY.iZ intrinsic. This intrinsic takes
@ -587,7 +587,7 @@ static Instruction *LowerPartSet(CallInst *CI) {
CI->getOperand(3),
CI->getOperand(4)
};
return new CallInst(F, Args, sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
}

2
lib/ExecutionEngine/JIT/JIT.cpp
View File

@ -224,7 +224,7 @@ GenericValue JIT::runFunction(Function *F,
Args.push_back(C);
}
CallInst *TheCall = new CallInst(F, &Args[0], Args.size(), "", StubBB);
CallInst *TheCall = new CallInst(F, Args.begin(), Args.end(), "", StubBB);
TheCall->setTailCall();
if (TheCall->getType() != Type::VoidTy)
new ReturnInst(TheCall, StubBB); // Return result of the call.

2
lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -450,7 +450,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
&Args[0], Args.size(), "", Call);
cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
} else {
New = new CallInst(NF, &Args[0], Args.size(), "", Call);
New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
if (cast<CallInst>(Call)->isTailCall())
cast<CallInst>(New)->setTailCall();

4
lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -177,7 +177,7 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
&Args[0], Args.size(), "", Call);
cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
} else {
New = new CallInst(NF, &Args[0], Args.size(), "", Call);
New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
if (cast<CallInst>(Call)->isTailCall())
cast<CallInst>(New)->setTailCall();
@ -543,7 +543,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) {
&Args[0], Args.size(), "", Call);
cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
} else {
New = new CallInst(NF, &Args[0], Args.size(), "", Call);
New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
if (cast<CallInst>(Call)->isTailCall())
cast<CallInst>(New)->setTailCall();

8
lib/Transforms/IPO/LowerSetJmp.cpp
View File

@ -49,6 +49,7 @@
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/VectorExtras.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
STATISTIC(LongJmpsTransformed, "Number of longjmps transformed");
@ -263,7 +264,10 @@ void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
// Inst's uses and doesn't get a name.
CastInst* CI =
new BitCastInst(Inst->getOperand(1), SBPTy, "LJBuf", Inst);
new CallInst(ThrowLongJmp, CI, Inst->getOperand(2), "", Inst);
SmallVector<Value *, 2> Args;
Args.push_back(CI);
Args.push_back(Inst->getOperand(2));
new CallInst(ThrowLongJmp, Args.begin(), Args.end(), "", Inst);
SwitchValuePair& SVP = SwitchValMap[Inst->getParent()->getParent()];
@ -381,7 +385,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst)
make_vector<Value*>(GetSetJmpMap(Func), BufPtr,
ConstantInt::get(Type::Int32Ty,
SetJmpIDMap[Func]++), 0);
new CallInst(AddSJToMap, &Args[0], Args.size(), "", Inst);
new CallInst(AddSJToMap, Args.begin(), Args.end(), "", Inst);
// We are guaranteed that there are no values live across basic blocks
// (because we are "not in SSA form" yet), but there can still be values live

2
lib/Transforms/IPO/PruneEH.cpp
View File

@ -153,7 +153,7 @@ bool PruneEH::SimplifyFunction(Function *F) {
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
// Insert a call instruction before the invoke.
CallInst *Call = new CallInst(II->getCalledValue(),
&Args[0], Args.size(), "", II);
Args.begin(), Args.end(), "", II);
Call->takeName(II);
Call->setCallingConv(II->getCallingConv());

32
lib/Transforms/IPO/SimplifyLibCalls.cpp
View File

@ -509,7 +509,7 @@ public:
ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1), // copy nul byte.
ConstantInt::get(Type::Int32Ty, 1) // alignment
};
new CallInst(SLC.get_memcpy(), Vals, 4, "", CI);
new CallInst(SLC.get_memcpy(), Vals, Vals + 4, "", CI);
return ReplaceCallWith(CI, Dst);
}
@ -549,7 +549,7 @@ public:
CI->getOperand(2),
ConstantInt::get(SLC.getIntPtrType(), Str.size()+1)
};
return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, 3,
return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, Args + 3,
CI->getName(), CI));
}
@ -752,7 +752,7 @@ public:
ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1),
ConstantInt::get(Type::Int32Ty, 1) // alignment
};
new CallInst(SLC.get_memcpy(), MemcpyOps, 4, "", CI);
new CallInst(SLC.get_memcpy(), MemcpyOps, MemcpyOps + 4, "", CI);
return ReplaceCallWith(CI, Dst);
}
@ -1294,7 +1294,7 @@ public:
ConstantInt::get(SLC.getIntPtrType(), 1),
CI->getOperand(1)
};
new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, 4, CI->getName(), CI);
new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, FWriteArgs + 4, CI->getName(), CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(),
FormatStr.size()));
}
@ -1311,7 +1311,10 @@ public:
const Type *FILETy = CI->getOperand(1)->getType();
Value *C = CastInst::createZExtOrBitCast(CI->getOperand(3), Type::Int32Ty,
CI->getName()+".int", CI);
new CallInst(SLC.get_fputc(FILETy), C, CI->getOperand(1), "", CI);
SmallVector<Value *, 2> Args;
Args.push_back(C);
Args.push_back(CI->getOperand(1));
new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
}
case 's': {
@ -1323,8 +1326,11 @@ public:
return false;
// fprintf(file,"%s",str) -> fputs(str,file)
new CallInst(SLC.get_fputs(FILETy), CastToCStr(CI->getOperand(3), CI),
CI->getOperand(1), CI->getName(), CI);
SmallVector<Value *, 2> Args;
Args.push_back(CastToCStr(CI->getOperand(3), CI));
Args.push_back(CI->getOperand(1));
new CallInst(SLC.get_fputs(FILETy), Args.begin(),
Args.end(), CI->getName(), CI);
return ReplaceCallWith(CI, 0);
}
default:
@ -1375,7 +1381,7 @@ public:
FormatStr.size()+1), // Copy the nul byte.
ConstantInt::get(Type::Int32Ty, 1)
};
new CallInst(SLC.get_memcpy(), MemCpyArgs, 4, "", CI);
new CallInst(SLC.get_memcpy(), MemCpyArgs, MemCpyArgs + 4, "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(),
FormatStr.size()));
}
@ -1412,7 +1418,7 @@ public:
Len,
ConstantInt::get(Type::Int32Ty, 1)
};
new CallInst(SLC.get_memcpy(), MemcpyArgs, 4, "", CI);
new CallInst(SLC.get_memcpy(), MemcpyArgs, MemcpyArgs + 4, "", CI);
// The strlen result is the unincremented number of bytes in the string.
if (!CI->use_empty()) {
@ -1464,7 +1470,7 @@ public:
ConstantInt::get(SLC.getIntPtrType(), 1),
CI->getOperand(2)
};
new CallInst(SLC.get_fwrite(FILETy), FWriteParms, 4, "", CI);
new CallInst(SLC.get_fwrite(FILETy), FWriteParms, FWriteParms + 4, "", CI);
return ReplaceCallWith(CI, 0); // Known to have no uses (see above).
}
} FPutsOptimizer;
@ -1505,12 +1511,14 @@ public:
// If this is writing one byte, turn it into fputc.
if (EltSize == 1 && EltCount == 1) {
SmallVector<Value *, 2> Args;
// fwrite(s,1,1,F) -> fputc(s[0],F)
Value *Ptr = CI->getOperand(1);
Value *Val = new LoadInst(Ptr, Ptr->getName()+".byte", CI);
Val = new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI);
Args.push_back(new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI));
Args.push_back(CI->getOperand(4));
const Type *FILETy = CI->getOperand(4)->getType();
new CallInst(SLC.get_fputc(FILETy), Val, CI->getOperand(4), "", CI);
new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
}
return false;

2
lib/Transforms/Instrumentation/ProfilingUtils.cpp
View File

@ -54,7 +54,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
}
Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
Instruction *InitCall = new CallInst(InitFn, &Args[0], Args.size(),
Instruction *InitCall = new CallInst(InitFn, Args.begin(), Args.end(),
"newargc", InsertPos);
// If argc or argv are not available in main, just pass null values in.

2
lib/Transforms/Scalar/ADCE.cpp
View File

@ -194,7 +194,7 @@ bool ADCE::doADCE() {
// The function cannot unwind. Convert it to a call with a branch
// after it to the normal destination.
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
CallInst *NewCall = new CallInst(F, &Args[0], Args.size(), "", II);
CallInst *NewCall = new CallInst(F, Args.begin(), Args.end(), "", II);
NewCall->takeName(II);
NewCall->setCallingConv(II->getCallingConv());
II->replaceAllUsesWith(NewCall);

2
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -7978,7 +7978,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
&Args[0], Args.size(), Caller->getName(), Caller);
cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv());
} else {
NC = new CallInst(Callee, &Args[0], Args.size(), Caller->getName(), Caller);
NC = new CallInst(Callee, Args.begin(), Args.end(), Caller->getName(), Caller);
if (cast<CallInst>(Caller)->isTailCall())
cast<CallInst>(NC)->setTailCall();
cast<CallInst>(NC)->setCallingConv(cast<CallInst>(Caller)->getCallingConv());

15
lib/Transforms/Scalar/LowerGC.cpp
View File

@ -27,6 +27,7 @@
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/Compiler.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
namespace {
@ -197,8 +198,18 @@ bool LowerGC::runOnFunction(Function &F) {
CI->setOperand(0, GCRead);
} else {
// Create a whole new call to replace the old one.
CallInst *NC = new CallInst(GCRead, CI->getOperand(1),
CI->getOperand(2),
// It sure would be nice to pass op_begin()+1,
// op_begin()+2 but it runs into trouble with
// CallInst::init's &*ierator, which requires a
// conversion from Use* to Value*. The conversion
// from Use to Value * is not useful because the
// memory for Value * won't be contiguous.
SmallVector<Value *, 2> Args;
Args.push_back(CI->getOperand(1));
Args.push_back(CI->getOperand(2));
CallInst *NC = new CallInst(GCRead, Args.begin(),
Args.end(),
CI->getName(), CI);
// These functions only deal with ptr type results so BitCast
// is the correct kind of cast (no-op cast).

4
lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -709,7 +709,7 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
ConstantInt::get(MI->getOperand(3)->getType(), EltSize), // Size
Zero // Align
};
new CallInst(TheFn, Ops, 4, "", MI);
new CallInst(TheFn, Ops, Ops + 4, "", MI);
} else {
assert(isa<MemSetInst>(MI));
Value *Ops[] = {
@ -717,7 +717,7 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
ConstantInt::get(MI->getOperand(3)->getType(), EltSize), // Size
Zero // Align
};
new CallInst(TheFn, Ops, 4, "", MI);
new CallInst(TheFn, Ops, Ops + 4, "", MI);
}
}

2
lib/Transforms/Utils/CodeExtractor.cpp
View File

@ -393,7 +393,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
}
// Emit the call to the function
CallInst *call = new CallInst(newFunction, &params[0], params.size(),
CallInst *call = new CallInst(newFunction, params.begin(), params.end(),
NumExitBlocks > 1 ? "targetBlock" : "");
codeReplacer->getInstList().push_back(call);

6
lib/Transforms/Utils/LowerInvoke.cpp
View File

@ -212,7 +212,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) {
std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
// Insert a normal call instruction...
CallInst *NewCall = new CallInst(II->getCalledValue(),
&CallArgs[0], CallArgs.size(), "", II);
CallArgs.begin(), CallArgs.end(), "", II);
NewCall->takeName(II);
NewCall->setCallingConv(II->getCallingConv());
II->replaceAllUsesWith(NewCall);
@ -269,7 +269,7 @@ void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo,
// Insert a normal call instruction.
std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
CallInst *NewCall = new CallInst(II->getCalledValue(),
&CallArgs[0], CallArgs.size(), "",
CallArgs.begin(), CallArgs.end(), "",
II);
NewCall->takeName(II);
NewCall->setCallingConv(II->getCallingConv());
@ -542,7 +542,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
Idx.push_back(ConstantInt::get(Type::Int32Ty, 0));
Idx[0] = new GetElementPtrInst(BufPtr, &Idx[0], 2, "JmpBuf", UnwindBlock);
Idx[1] = ConstantInt::get(Type::Int32Ty, 1);
new CallInst(LongJmpFn, &Idx[0], Idx.size(), "", UnwindBlock);
new CallInst(LongJmpFn, Idx.begin(), Idx.end(), "", UnwindBlock);
new UnreachableInst(UnwindBlock);
// Set up the term block ("throw without a catch").

4
lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -1374,7 +1374,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
// Insert the call now...
SmallVector<Value*,8> Args(II->op_begin()+3, II->op_end());
CallInst *CI = new CallInst(II->getCalledValue(),
&Args[0], Args.size(), II->getName(), BI);
Args.begin(), Args.end(), II->getName(), BI);
CI->setCallingConv(II->getCallingConv());
// If the invoke produced a value, the Call now does instead
II->replaceAllUsesWith(CI);
@ -1748,7 +1748,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
// Insert the call now...
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
CallInst *CI = new CallInst(II->getCalledValue(),
&Args[0], Args.size(),
Args.begin(), Args.end(),
II->getName(), BI);
CI->setCallingConv(II->getCallingConv());
// If the invoke produced a value, the Call does now instead.

13
lib/VMCore/Instructions.cpp
View File

@ -267,19 +267,21 @@ void CallInst::init(Value *Func) {
assert(FTy->getNumParams() == 0 && "Calling a function with bad signature");
}
#if 0
// Leave for llvm-gcc
CallInst::CallInst(Value *Func, Value* const *Args, unsigned NumArgs,
const std::string &Name, BasicBlock *InsertAtEnd)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
->getElementType())->getReturnType(),
->getElementType())->getReturnType(),
Instruction::Call, 0, 0, InsertAtEnd) {
init(Func, Args, NumArgs);
setName(Name);
}
CallInst::CallInst(Value *Func, Value* const *Args, unsigned NumArgs,
const std::string &Name, Instruction *InsertBefore)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
->getElementType())->getReturnType(),
Instruction::Call, 0, 0, InsertBefore) {
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
->getElementType())->getReturnType(),
Instruction::Call, 0, 0, InsertBefore) {
init(Func, Args, NumArgs);
setName(Name);
}
@ -301,7 +303,7 @@ CallInst::CallInst(Value *Func, Value *Actual1, Value *Actual2,
init(Func, Actual1, Actual2);
setName(Name);
}
#endif
CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
Instruction *InsertBefore)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
@ -319,7 +321,6 @@ CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
init(Func, Actual);
setName(Name);
}
CallInst::CallInst(Value *Func, const std::string &Name,
Instruction *InsertBefore)
: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())

10
tools/bugpoint/Miscompilation.cpp
View File

@ -663,7 +663,7 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
// Call the old main function and return its result
BasicBlock *BB = new BasicBlock("entry", newMain);
CallInst *call = new CallInst(oldMainProto, &args[0], args.size(),
CallInst *call = new CallInst(oldMainProto, args.begin(), args.end(),
"", BB);
// If the type of old function wasn't void, return value of call
@ -734,8 +734,8 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
// Resolve the call to function F via the JIT API:
//
// call resolver(GetElementPtr...)
CallInst *Resolver = new CallInst(resolverFunc, &ResolverArgs[0],
ResolverArgs.size(),
CallInst *Resolver = new CallInst(resolverFunc, ResolverArgs.begin(),
ResolverArgs.end(),
"resolver", LookupBB);
// cast the result from the resolver to correctly-typed function
CastInst *CastedResolver = new BitCastInst(Resolver,
@ -757,10 +757,10 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
// Pass on the arguments to the real function, return its result
if (F->getReturnType() == Type::VoidTy) {
new CallInst(FuncPtr, &Args[0], Args.size(), "", DoCallBB);
new CallInst(FuncPtr, Args.begin(), Args.end(), "", DoCallBB);
new ReturnInst(DoCallBB);
} else {
CallInst *Call = new CallInst(FuncPtr, &Args[0], Args.size(),
CallInst *Call = new CallInst(FuncPtr, Args.begin(), Args.end(),
"retval", DoCallBB);
new ReturnInst(Call, DoCallBB);
}

17
tools/llvm-upgrade/UpgradeParser.y
View File

@ -1513,7 +1513,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
const PointerType *PFTy = PointerType::get(FTy);
Value* Func = getVal(PFTy, ID);
Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
return new CallInst(Func, &Args[0], Args.size());
return new CallInst(Func, Args.begin(), Args.end());
} else if (Name == "llvm.va_copy") {
if (Args.size() != 2)
error("Invalid prototype for " + Name + " prototype");
@ -1527,7 +1527,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
std::string InstName1(makeNameUnique("va1"));
Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
return new CallInst(Func, &Args[0], Args.size());
return new CallInst(Func, Args.begin(), Args.end());
}
}
}
@ -1751,11 +1751,12 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in,
while (!F->use_empty()) {
CallInst* CI = cast<CallInst>(F->use_back());
AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
new StoreInst(CI->getOperand(1), b, CI);
new CallInst(NF, a, b, "", CI);
Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
SmallVector<Value *, 2> Args;
Args.push_back(new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI));
Args.push_back(new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI));
new StoreInst(CI->getOperand(1), Args[1], CI);
new CallInst(NF, Args.begin(), Args.end(), "", CI);
Value* foo = new LoadInst(Args[0], "vacopy.fix.3", CI);
CI->replaceAllUsesWith(foo);
CI->getParent()->getInstList().erase(CI);
}
@ -3806,7 +3807,7 @@ InstVal
}
// Create the call instruction
CallInst *CI = new CallInst(V, &Args[0], Args.size());
CallInst *CI = new CallInst(V, Args.begin(), Args.end());
CI->setTailCall($1);
CI->setCallingConv(upgradeCallingConv($2));
$$.I = CI;