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

Remove support for printing values from a module by name, only used

Browse Source 
w/ interactive keyboard entry of names.
With that, Support.cpp is history.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8360 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Brian Gaeke
2003-09-05 05:04:32 +00:00
parent 413ab6655b
commit 932539a941
3 changed files with 0 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -1086,20 +1086,3 @@ void Interpreter::print(const Type *Ty, GenericValue V) {
CW << Ty << " "; CW << Ty << " ";
printValue(Ty, V); printValue(Ty, V);
} }
void Interpreter::print(const std::string &Name) {
Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
if (!PickedVal) return;
if (const Function *F = dyn_cast<Function>(PickedVal)) {
CW << F; // Print the function
} else if (const Type *Ty = dyn_cast<Type>(PickedVal)) {
CW << "type %" << Name << " = " << Ty->getDescription() << "\n";
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(PickedVal)) {
CW << BB; // Print the basic block
} else { // Otherwise there should be an annotation for the slot#
print(PickedVal->getType(),
getOperandValue(PickedVal, ECStack[CurFrame]));
std::cout << "\n";
}
}

15
lib/ExecutionEngine/Interpreter/Interpreter.h
View File

@ -103,7 +103,6 @@ public:
// User Interation Methods... // User Interation Methods...
bool callFunction(const std::string &Name); // return true on failure bool callFunction(const std::string &Name); // return true on failure
void print(const std::string &Name);
static void print(const Type *Ty, GenericValue V); static void print(const Type *Ty, GenericValue V);
static void printValue(const Type *Ty, GenericValue V); static void printValue(const Type *Ty, GenericValue V);
@ -181,20 +180,6 @@ private: // Helper functions
// //
void printCurrentInstruction(); void printCurrentInstruction();
// 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);
// ChooseOneOption - Prompt the user to choose among the specified options to
// pick one value. If no options are provided, emit an error. If a single
// option is provided, just return that option.
//
Value *ChooseOneOption(const std::string &Name,
const std::vector<Value*> &Opts);
void initializeExecutionEngine(); void initializeExecutionEngine();
void initializeExternalFunctions(); void initializeExternalFunctions();
}; };

77
lib/ExecutionEngine/Interpreter/Support.cpp
View File

@ -1,77 +0,0 @@
//===-- Support.cpp - Support routines for interpreter --------------------===//
//
// This file contains support routines for the interpreter core.
//
//===----------------------------------------------------------------------===//
#include "Interpreter.h"
#include "llvm/SymbolTable.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Module.h"
//===----------------------------------------------------------------------===//
//
// LookupMatchingNames helper - Search a symbol table for values matching Name.
//
static inline void LookupMatchingNames(const std::string &Name,
SymbolTable &SymTab,
std::vector<Value*> &Results) {
// Loop over all of the type planes in the symbol table...
for (SymbolTable::iterator I = SymTab.begin(), E = SymTab.end(); I != E; ++I){
SymbolTable::VarMap &Plane = I->second;
// Search the symbol table plane for this name...
SymbolTable::VarMap::iterator Val = Plane.find(Name);
if (Val != Plane.end())
Results.push_back(Val->second); // Found a name match!
}
}
// 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;
Function *CurFunc = getCurrentFunction();
if (CurFunc) ::LookupMatchingNames(Name, CurFunc->getSymbolTable(), Results);
::LookupMatchingNames(Name, getModule().getSymbolTable(), Results);
return Results;
}
// ChooseOneOption - Prompt the user to choose among the specified options to
// pick one value. If no options are provided, emit an error. If a single
// option is provided, just return that option.
//
Value *Interpreter::ChooseOneOption(const std::string &Name,
const std::vector<Value*> &Opts) {
switch (Opts.size()) {
case 1: return Opts[0];
case 0:
std::cout << "Error: no entities named '" << Name << "' found!\n";
return 0;
default: break; // Must prompt user...
}
std::cout << "Multiple entities named '" << Name
<< "' found! Please choose:\n";
std::cout << " 0. Cancel operation\n";
for (unsigned i = 0; i < Opts.size(); ++i) {
std::cout << " " << (i+1) << ".";
WriteAsOperand(std::cout, Opts[i]) << "\n";
}
unsigned Option;
do {
std::cout << "lli> " << std::flush;
std::cin >> Option;
if (Option > Opts.size())
std::cout << "Invalid selection: Please choose from 0 to " << Opts.size()
<< "\n";
} while (Option > Opts.size());
if (Option == 0) return 0;
return Opts[Option-1];
}