Change references to the Method class to be references to the Function
class. The Method class is obsolete (renamed) and all references to it
are being converted over to Function.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2144 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp
index 2260625..484dbe2 100644
--- a/lib/ExecutionEngine/Interpreter/Execution.cpp
+++ b/lib/ExecutionEngine/Interpreter/Execution.cpp
@@ -233,15 +233,15 @@
// This annotation will only be created on GlobalValue objects...
GlobalValue *GVal = cast<GlobalValue>((Value*)O);
- if (isa<Method>(GVal)) {
- // The GlobalAddress object for a method is just a pointer to method itself.
- // Don't delete it when the annotation is gone though!
+ if (isa<Function>(GVal)) {
+ // The GlobalAddress object for a function is just a pointer to function
+ // itself. Don't delete it when the annotation is gone though!
return new GlobalAddress(GVal, false);
}
// Handle the case of a global variable...
assert(isa<GlobalVariable>(GVal) &&
- "Global value found that isn't a method or global variable!");
+ "Global value found that isn't a function or global variable!");
GlobalVariable *GV = cast<GlobalVariable>(GVal);
// First off, we must allocate space for the global variable to point at...
@@ -667,7 +667,7 @@
}
// Save previously executing meth
- const Method *M = ECStack.back().CurMethod;
+ const Function *M = ECStack.back().CurMethod;
// Pop the current stack frame... this invalidates SF
ECStack.pop_back();
@@ -675,7 +675,7 @@
if (ECStack.empty()) { // Finished main. Put result into exit code...
if (RetTy) { // Nonvoid return type?
if (!QuietMode) {
- CW << "Method " << M->getType() << " \"" << M->getName()
+ CW << "Function " << M->getType() << " \"" << M->getName()
<< "\" returned ";
print(RetTy, Result);
cout << "\n";
@@ -703,7 +703,7 @@
} else if (!QuietMode) {
// This must be a function that is executing because of a user 'call'
// instruction.
- CW << "Method " << M->getType() << " \"" << M->getName()
+ CW << "Function " << M->getType() << " \"" << M->getName()
<< "\" returned ";
print(RetTy, Result);
cout << "\n";
@@ -894,10 +894,10 @@
ArgVals.push_back(getOperandValue(I->getOperand(i), SF));
// To handle indirect calls, we must get the pointer value from the argument
- // and treat it as a method pointer.
+ // and treat it as a function pointer.
GenericValue SRC = getOperandValue(I->getCalledValue(), SF);
- callMethod((Method*)SRC.PointerVal, ArgVals);
+ callMethod((Function*)SRC.PointerVal, ArgVals);
}
static void executePHINode(PHINode *I, ExecutionContext &SF) {
@@ -1024,16 +1024,16 @@
// Dispatch and Execution Code
//===----------------------------------------------------------------------===//
-MethodInfo::MethodInfo(Method *M) : Annotation(MethodInfoAID) {
- // Assign slot numbers to the method arguments...
- const Method::ArgumentListType &ArgList = M->getArgumentList();
- for (Method::ArgumentListType::const_iterator AI = ArgList.begin(),
+MethodInfo::MethodInfo(Function *M) : Annotation(MethodInfoAID) {
+ // Assign slot numbers to the function arguments...
+ const Function::ArgumentListType &ArgList = M->getArgumentList();
+ for (Function::ArgumentListType::const_iterator AI = ArgList.begin(),
AE = ArgList.end(); AI != AE; ++AI)
(*AI)->addAnnotation(new SlotNumber(getValueSlot(*AI)));
// Iterate over all of the instructions...
unsigned InstNum = 0;
- for (Method::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) {
+ for (Function::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) {
BasicBlock *BB = *MI;
for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II){
Instruction *I = *II; // For each instruction... Add Annote
@@ -1051,9 +1051,9 @@
//===----------------------------------------------------------------------===//
-// callMethod - Execute the specified method...
+// callMethod - Execute the specified function...
//
-void Interpreter::callMethod(Method *M, const vector<GenericValue> &ArgVals) {
+void Interpreter::callMethod(Function *M, const vector<GenericValue> &ArgVals) {
assert((ECStack.empty() || ECStack.back().Caller == 0 ||
ECStack.back().Caller->getNumOperands()-1 == ArgVals.size()) &&
"Incorrect number of arguments passed into function call!");
@@ -1071,7 +1071,7 @@
SF.Caller = 0; // We returned from the call...
} else if (!QuietMode) {
// print it.
- CW << "Method " << M->getType() << " \"" << M->getName()
+ CW << "Function " << M->getType() << " \"" << M->getName()
<< "\" returned ";
print(RetTy, Result);
cout << "\n";
@@ -1084,8 +1084,9 @@
return;
}
- // Process the method, assigning instruction numbers to the instructions in
- // the method. Also calculate the number of values for each type slot active.
+ // Process the function, assigning instruction numbers to the instructions in
+ // the function. Also calculate the number of values for each type slot
+ // active.
//
MethodInfo *MethInfo = (MethodInfo*)M->getOrCreateAnnotation(MethodInfoAID);
ECStack.push_back(ExecutionContext()); // Make a new stack frame...
@@ -1109,11 +1110,11 @@
StackFrame.PrevBB = 0; // No previous BB for PHI nodes...
- // Run through the method arguments and initialize their values...
+ // Run through the function arguments and initialize their values...
assert(ArgVals.size() == M->getArgumentList().size() &&
- "Invalid number of values passed to method invocation!");
+ "Invalid number of values passed to function invocation!");
unsigned i = 0;
- for (Method::ArgumentListType::iterator MI = M->getArgumentList().begin(),
+ for (Function::ArgumentListType::iterator MI = M->getArgumentList().begin(),
ME = M->getArgumentList().end(); MI != ME; ++MI, ++i) {
SetValue(*MI, ArgVals[i], StackFrame);
}
@@ -1319,8 +1320,8 @@
Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
if (!PickedVal) return;
- if (const Method *M = dyn_cast<const Method>(PickedVal)) {
- CW << M; // Print the method
+ if (const Function *F = dyn_cast<const Function>(PickedVal)) {
+ CW << F; // Print the function
} else if (const Type *Ty = dyn_cast<const Type>(PickedVal)) {
CW << "type %" << Name << " = " << Ty->getDescription() << "\n";
} else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(PickedVal)) {
@@ -1348,13 +1349,13 @@
//
void Interpreter::printStackFrame(int FrameNo = -1) {
if (FrameNo == -1) FrameNo = CurFrame;
- Method *Meth = ECStack[FrameNo].CurMethod;
- const Type *RetTy = Meth->getReturnType();
+ Function *Func = ECStack[FrameNo].CurMethod;
+ const Type *RetTy = Func->getReturnType();
CW << ((FrameNo == CurFrame) ? '>' : '-') << "#" << FrameNo << ". "
- << (Value*)RetTy << " \"" << Meth->getName() << "\"(";
+ << (Value*)RetTy << " \"" << Func->getName() << "\"(";
- Method::ArgumentListType &Args = Meth->getArgumentList();
+ Function::ArgumentListType &Args = Func->getArgumentList();
for (unsigned i = 0; i < Args.size(); ++i) {
if (i != 0) cout << ", ";
CW << (Value*)Args[i] << "=";
diff --git a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h
index 537d18c..03abd20 100644
--- a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h
+++ b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h
@@ -11,18 +11,18 @@
// Support for MethodInfo annotations
//===----------------------------------------------------------------------===//
-// This annotation (attached only to Method objects) is used to cache useful
-// information about the method, including the number of types present in the
-// method, and the number of values for each type.
+// This annotation (attached only to Function objects) is used to cache useful
+// information about the function, including the number of types present in the
+// function, and the number of values for each type.
//
// This annotation object is created on demand, and attaches other annotation
-// objects to the instructions in the method when it's created.
+// objects to the instructions in the function when it's created.
//
static AnnotationID MethodInfoAID(
- AnnotationManager::getID("Interpreter::MethodInfo"));
+ AnnotationManager::getID("Interpreter::FunctionInfo"));
struct MethodInfo : public Annotation {
- MethodInfo(Method *M);
+ MethodInfo(Function *F);
std::vector<unsigned> NumPlaneElements;
@@ -31,7 +31,7 @@
//
static Annotation *Create(AnnotationID AID, const Annotable *O, void *) {
assert(AID == MethodInfoAID);
- return new MethodInfo(cast<Method>((Value*)O)); // Simply invoke the ctor
+ return new MethodInfo(cast<Function>((Value*)O)); // Simply invoke the ctor
}
private:
@@ -47,7 +47,7 @@
// used to hold the the slot number for the value in its type plane.
//
// Entities have this annotation attached to them when the containing
-// method has it's MethodInfo created (by the MethodInfo ctor).
+// function has it's MethodInfo created (by the MethodInfo ctor).
//
static AnnotationID SlotNumberAID(
AnnotationManager::getID("Interpreter::SlotNumber"));
@@ -71,8 +71,8 @@
// its type plane. InstNumber's are used for user interaction, and for
// calculating which value slot to store the result of the instruction in.
//
-// Instructions have this annotation attached to them when the containing method
-// has it's MethodInfo created (by the MethodInfo ctor).
+// Instructions have this annotation attached to them when the containing
+// function has it's MethodInfo created (by the MethodInfo ctor).
//
struct InstNumber : public SlotNumber {
unsigned InstNum; // Ranges from 1->
@@ -95,10 +95,11 @@
//===----------------------------------------------------------------------===//
// This annotation (attached only to GlobalValue objects) is used to hold the
-// address of the chunk of memory that represents a global value. For Method's,
-// this pointer is the Method object pointer that represents it. For global
-// variables, this is the dynamically allocated (and potentially initialized)
-// chunk of memory for the global. This annotation is created on demand.
+// address of the chunk of memory that represents a global value. For
+// Functions, this pointer is the Function object pointer that represents it.
+// For global variables, this is the dynamically allocated (and potentially
+// initialized) chunk of memory for the global. This annotation is created on
+// demand.
//
static AnnotationID GlobalAddressAID(
AnnotationManager::getID("Interpreter::GlobalAddress"));
diff --git a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
index c8aa46a..8f486e8 100644
--- a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
+++ b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
@@ -1,11 +1,12 @@
-//===-- ExternalMethods.cpp - Implement External Functions ----------------===//
+//===-- ExternalFunctions.cpp - Implement External Functions --------------===//
//
-// This file contains both code to deal with invoking "external" methods, but
-// also contains code that implements "exported" external methods.
+// This file contains both code to deal with invoking "external" functions, but
+// also contains code that implements "exported" external functions.
//
-// External methods in LLI are implemented by dlopen'ing the lli executable and
-// using dlsym to look op the methods that we want to invoke. If a method is
-// found, then the arguments are mangled and passed in to the function call.
+// External functions in LLI are implemented by dlopen'ing the lli executable
+// and using dlsym to look op the functions that we want to invoke. If a
+// function is found, then the arguments are mangled and passed in to the
+// function call.
//
//===----------------------------------------------------------------------===//
@@ -91,18 +92,19 @@
const vector<GenericValue> &ArgVals) {
TheInterpreter = this;
- // Do a lookup to see if the method is in our cache... this should just be a
+ // Do a lookup to see if the function is in our cache... this should just be a
// defered annotation!
std::map<const Function *, ExFunc>::iterator FI = Functions.find(M);
ExFunc Fn = (FI == Functions.end()) ? lookupFunction(M) : FI->second;
if (Fn == 0) {
- cout << "Tried to execute an unknown external method: "
+ cout << "Tried to execute an unknown external function: "
<< M->getType()->getDescription() << " " << M->getName() << "\n";
return GenericValue();
}
// TODO: FIXME when types are not const!
- GenericValue Result = Fn(const_cast<FunctionType*>(M->getFunctionType()),ArgVals);
+ GenericValue Result = Fn(const_cast<FunctionType*>(M->getFunctionType()),
+ ArgVals);
return Result;
}
diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h
index 8576f9c..e7c7942 100644
--- a/lib/ExecutionEngine/Interpreter/Interpreter.h
+++ b/lib/ExecutionEngine/Interpreter/Interpreter.h
@@ -12,7 +12,7 @@
#include "llvm/Module.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "Support/DataTypes.h"
#include "llvm/Assembly/CachedWriter.h"
@@ -78,10 +78,10 @@
// executing.
//
struct ExecutionContext {
- Method *CurMethod; // The currently executing method
+ Function *CurMethod; // The currently executing function
BasicBlock *CurBB; // The currently executing BB
BasicBlock::iterator CurInst; // The next instruction to execute
- MethodInfo *MethInfo; // The MethInfo annotation for the method
+ MethodInfo *MethInfo; // The MethInfo annotation for the function
std::vector<ValuePlaneTy> Values;// ValuePlanes for each type
BasicBlock *PrevBB; // The previous BB or null if in first BB
@@ -100,7 +100,7 @@
int CurFrame; // The current stack frame being inspected
// The runtime stack of executing code. The top of the stack is the current
- // method record.
+ // function record.
std::vector<ExecutionContext> ECStack;
public:
@@ -135,7 +135,7 @@
void printStackTrace(); // Do the 'backtrace' command
// Code execution methods...
- void callMethod(Method *Meth, const std::vector<GenericValue> &ArgVals);
+ void callMethod(Function *F, const std::vector<GenericValue> &ArgVals);
bool executeInstruction(); // Execute one instruction...
void stepInstruction(); // Do the 'step' command
@@ -148,12 +148,12 @@
void executeRetInst(ReturnInst *I, ExecutionContext &SF);
void executeBrInst(BranchInst *I, ExecutionContext &SF);
void executeAllocInst(AllocationInst *I, ExecutionContext &SF);
- GenericValue callExternalMethod(Method *Meth,
+ GenericValue callExternalMethod(Function *F,
const std::vector<GenericValue> &ArgVals);
void exitCalled(GenericValue GV);
// getCurrentMethod - Return the currently executing method
- inline Method *getCurrentMethod() const {
+ inline Function *getCurrentMethod() const {
return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod;
}
@@ -178,10 +178,10 @@
//
void printStackFrame(int FrameNo = -1);
- // LookupMatchingNames - Search the current method namespace, then the global
- // namespace looking for values that match the specified name. Return ALL
- // matches to that name. This is obviously slow, and should only be used for
- // user interaction.
+ // LookupMatchingNames - Search the current function namespace, then the
+ // global namespace looking for values that match the specified name. Return
+ // ALL matches to that name. This is obviously slow, and should only be used
+ // for user interaction.
//
std::vector<Value*> LookupMatchingNames(const std::string &Name);
diff --git a/lib/ExecutionEngine/Interpreter/Support.cpp b/lib/ExecutionEngine/Interpreter/Support.cpp
index ca89ae3..cac3b74 100644
--- a/lib/ExecutionEngine/Interpreter/Support.cpp
+++ b/lib/ExecutionEngine/Interpreter/Support.cpp
@@ -31,14 +31,14 @@
}
}
-// LookupMatchingNames - Search the current method namespace, then the global
+// LookupMatchingNames - Search the current function namespace, then the global
// namespace looking for values that match the specified name. Return ALL
// matches to that name. This is obviously slow, and should only be used for
// user interaction.
//
std::vector<Value*> Interpreter::LookupMatchingNames(const std::string &Name) {
std::vector<Value*> Results;
- Method *CurMeth = getCurrentMethod();
+ Function *CurMeth = getCurrentMethod();
if (CurMeth) ::LookupMatchingNames(Name, *CurMeth, Results);
if (CurMod ) ::LookupMatchingNames(Name, *CurMod , Results);
diff --git a/lib/ExecutionEngine/Interpreter/UserInput.cpp b/lib/ExecutionEngine/Interpreter/UserInput.cpp
index 99ee6ec..b35463f 100644
--- a/lib/ExecutionEngine/Interpreter/UserInput.cpp
+++ b/lib/ExecutionEngine/Interpreter/UserInput.cpp
@@ -124,7 +124,7 @@
case Finish: finish(); break;
case Call:
cin >> Command;
- callMethod(Command); // Enter the specified method
+ callMethod(Command); // Enter the specified function
finish(); // Run until it's complete
break;
@@ -215,7 +215,7 @@
bool Interpreter::callMethod(const string &Name) {
std::vector<Value*> Options = LookupMatchingNames(Name);
- for (unsigned i = 0; i < Options.size(); ++i) { // Remove nonmethod matches...
+ for (unsigned i = 0; i < Options.size(); ++i) { // Remove non-fn matches...
if (!isa<Function>(Options[i])) {
Options.erase(Options.begin()+i);
--i;
@@ -263,7 +263,7 @@
const std::vector<string> &InputArgv) {
std::vector<Value*> Options = LookupMatchingNames(Name);
- for (unsigned i = 0; i < Options.size(); ++i) { // Remove nonmethod matches...
+ for (unsigned i = 0; i < Options.size(); ++i) { // Remove non-fn matches...
if (!isa<Function>(Options[i])) {
Options.erase(Options.begin()+i);
--i;
@@ -321,7 +321,7 @@
if (ECStack.empty())
cout << "Error: No program executing!\n";
else
- CW << ECStack[CurFrame].CurMethod; // Just print the method out...
+ CW << ECStack[CurFrame].CurMethod; // Just print the function out...
}
void Interpreter::printStackTrace() {