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

Changed the fundemental architecture of Operands for Instructions. Now

Browse Source 
Operands are maintained as a vector<Use> in the User class, and operator
iterators are provided as before.  Getting an operand no longer requires
a virtual function call.

WARNING: getOperand(x) where x >= getNumOperands() will now assert instead
of returning null!


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@149 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2001-07-07 08:36:50 +00:00
parent f0d0e9c262
commit c8b25d40cb
25 changed files with 308 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/VMCore/iCall.cpp
+13 -24
View File
@@ -1,6 +1,6 @@
//===-- iCall.cpp - Implement the Call & Invoke instructions -----*- C++ -*--=//
//===-- iCall.cpp - Implement the call & icall instructions ------*- C++ -*--=//
//
// This file implements the call and invoke instructions.
// This file implements the call and icall instructions.
//
//===----------------------------------------------------------------------===//
@@ -8,9 +8,12 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Method.h"
CallInst::CallInst(Method *m, vector<Value*> &params,
CallInst::CallInst(Method *M, vector<Value*> &params,
const string &Name)
: Instruction(m->getReturnType(), Instruction::Call, Name), M(m, this) {
: Instruction(M->getReturnType(), Instruction::Call, Name) {
Operands.reserve(1+params.size());
Operands.push_back(Use(M, this));
const MethodType* MT = M->getMethodType();
const MethodType::ParamTypes &PL = MT->getParamTypes();
@@ -19,29 +22,15 @@ CallInst::CallInst(Method *m, vector<Value*> &params,
MethodType::ParamTypes::const_iterator It = PL.begin();
#endif
for (unsigned i = 0; i < params.size(); i++) {
assert(*It++ == params[i]->getType());
Params.push_back(Use(params[i], this));
assert(*It++ == params[i]->getType() && "Call Operands not correct type!");
Operands.push_back(Use(params[i], this));
}
}
CallInst::CallInst(const CallInst &CI)
: Instruction(CI.getType(), Instruction::Call), M(CI.M, this) {
for (unsigned i = 0; i < CI.Params.size(); i++)
Params.push_back(Use(CI.Params[i], this));
: Instruction(CI.getType(), Instruction::Call) {
Operands.reserve(CI.Operands.size());
for (unsigned i = 0; i < CI.Operands.size(); ++i)
Operands.push_back(Use(CI.Operands[i], this));
}
void CallInst::dropAllReferences() {
M = 0;
Params.clear();
}
bool CallInst::setOperand(unsigned i, Value *Val) {
if (i > Params.size()) return false;
if (i == 0) {
M = Val->castMethodAsserting();
} else {
// TODO: assert = method arg type
Params[i-1] = Val;
}
return true;
}