diff options
Diffstat (limited to 'lib/Bytecode')
| -rw-r--r-- | lib/Bytecode/Writer/SlotCalculator.cpp | 8 | ||||
| -rw-r--r-- | lib/Bytecode/Writer/SlotCalculator.h | 28 | ||||
| -rw-r--r-- | lib/Bytecode/Writer/Writer.cpp | 23 | ||||
| -rw-r--r-- | lib/Bytecode/Writer/WriterInternals.h | 2 |
4 files changed, 31 insertions, 30 deletions
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp index 9c59f12047..4a8312e613 100644 --- a/lib/Bytecode/Writer/SlotCalculator.cpp +++ b/lib/Bytecode/Writer/SlotCalculator.cpp @@ -9,7 +9,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/SlotCalculator.h" +#include "llvm/SlotCalculator.h" #include "llvm/Analysis/ConstantsScanner.h" #include "llvm/Function.h" #include "llvm/GlobalVariable.h" @@ -60,7 +60,7 @@ SlotCalculator::SlotCalculator(const Function *M, bool IgnoreNamed) { if (TheModule == 0) return; // Empty table... processModule(); // Process module level stuff - incorporateMethod(M); // Start out in incorporated state + incorporateFunction(M); // Start out in incorporated state } @@ -119,7 +119,7 @@ void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) { } -void SlotCalculator::incorporateMethod(const Function *M) { +void SlotCalculator::incorporateFunction(const Function *M) { assert(ModuleLevel.size() == 0 && "Module already incorporated!"); SC_DEBUG("begin processFunction!\n"); @@ -182,7 +182,7 @@ void SlotCalculator::incorporateMethod(const Function *M) { SC_DEBUG("end processFunction!\n"); } -void SlotCalculator::purgeMethod() { +void SlotCalculator::purgeFunction() { assert(ModuleLevel.size() != 0 && "Module not incorporated!"); unsigned NumModuleTypes = ModuleLevel.size(); diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h index 9d5d2240af..d80515d137 100644 --- a/lib/Bytecode/Writer/SlotCalculator.h +++ b/lib/Bytecode/Writer/SlotCalculator.h @@ -1,13 +1,17 @@ -//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==// +//===-- llvm/SlotCalculator.h - Calculate value slots ------------*- C++ -*-==// // -// This ModuleAnalyzer subclass calculates the slots that values will land in. -// This is useful for when writing bytecode or assembly out, because you have -// to know these things. +// This class calculates the slots that values will land in. This is useful for +// when writing bytecode or assembly out, because you have to know these things. +// +// Specifically, this class calculates the "type plane numbering" that you see +// for a function if you strip out all of the symbols in it. For assembly +// writing, this is used when a symbol does not have a name. For bytecode +// writing, this is always used, and the symbol table is added on later. // //===----------------------------------------------------------------------===// -#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H -#define LLVM_ANALYSIS_SLOTCALCULATOR_H +#ifndef LLVM_SLOTCALCULATOR_H +#define LLVM_SLOTCALCULATOR_H #include "llvm/SymTabValue.h" #include <vector> @@ -25,7 +29,7 @@ class SlotCalculator { std::map<const Value *, unsigned> NodeMap; // ModuleLevel - Used to keep track of which values belong to the module, - // and which values belong to the currently incorporated method. + // and which values belong to the currently incorporated function. // std::vector<unsigned> ModuleLevel; @@ -47,11 +51,11 @@ public: return Table[Plane]; } - // If you'd like to deal with a method, use these two methods to get its data - // into the SlotCalculator! + // If you'd like to deal with a function, use these two methods to get its + // data into the SlotCalculator! // - void incorporateMethod(const Function *F); - void purgeMethod(); + void incorporateFunction(const Function *F); + void purgeFunction(); protected: // insertVal - Insert a value into the value table... Return the slot that it @@ -68,7 +72,7 @@ protected: // doInsertVal - Small helper function to be called only be insertVal. int doInsertVal(const Value *D); - // processModule - Process all of the module level method declarations and + // processModule - Process all of the module level function declarations and // types that are available. // void processModule(); diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp index af53ee5c0e..0b883acd58 100644 --- a/lib/Bytecode/Writer/Writer.cpp +++ b/lib/Bytecode/Writer/Writer.cpp @@ -2,9 +2,6 @@ // // This library implements the functionality defined in llvm/Bytecode/Writer.h // -// This library uses the Analysis library to figure out offsets for -// variables in the method tables... -// // Note that this file uses an unusual technique of outputting all the bytecode // to a deque of unsigned char's, then copies the deque to an ostream. The // reason for this is that we must do "seeking" in the stream to do back- @@ -46,13 +43,13 @@ BytecodeWriter::BytecodeWriter(std::deque<unsigned char> &o, const Module *M) output_vbr((unsigned)Type::FirstDerivedTyID, Out); align32(Out); - // Output module level constants, including types used by the method protos + // Output module level constants, including types used by the function protos outputConstants(false); // The ModuleInfoBlock follows directly after the Module constant pool outputModuleInfoBlock(M); - // Do the whole module now! Process each method at a time... + // Do the whole module now! Process each function at a time... for_each(M->begin(), M->end(), bind_obj(this, &BytecodeWriter::processMethod)); @@ -75,7 +72,7 @@ void BytecodeWriter::outputConstants(bool isFunction) { else if (pno == Type::TypeTyID) ValNo = Type::FirstDerivedTyID; // Start emitting at the derived types... - // Scan through and ignore method arguments... + // Scan through and ignore function arguments... for (; ValNo < Plane.size() && isa<FunctionArgument>(Plane[ValNo]); ValNo++) /*empty*/; @@ -92,7 +89,7 @@ void BytecodeWriter::outputConstants(bool isFunction) { // Output the Type ID Number... int Slot = Table.getValSlot(Plane.front()->getType()); - assert (Slot != -1 && "Type in constant pool but not in method!!"); + assert (Slot != -1 && "Type in constant pool but not in function!!"); output_vbr((unsigned)Slot, Out); //cerr << "Emitting " << NC << " constants of type '" @@ -136,7 +133,7 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) { } output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out); - // Output the types of the methods in this module... + // Output the types of the functions in this module... for (Module::const_iterator I = M->begin(), End = M->end(); I != End; ++I) { int Slot = Table.getValSlot((*I)->getType()); assert(Slot != -1 && "Module const pool is broken!"); @@ -155,21 +152,21 @@ void BytecodeWriter::processMethod(const Function *M) { // Only output the constant pool and other goodies if needed... if (!M->isExternal()) { - // Get slot information about the method... - Table.incorporateMethod(M); + // Get slot information about the function... + Table.incorporateFunction(M); - // Output information about the constants in the method... + // Output information about the constants in the function... outputConstants(true); // Output basic block nodes... for_each(M->begin(), M->end(), bind_obj(this, &BytecodeWriter::processBasicBlock)); - // If needed, output the symbol table for the method... + // If needed, output the symbol table for the function... if (M->hasSymbolTable()) outputSymbolTable(*M->getSymbolTable()); - Table.purgeMethod(); + Table.purgeFunction(); } } diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h index 10170305b3..62f12db91f 100644 --- a/lib/Bytecode/Writer/WriterInternals.h +++ b/lib/Bytecode/Writer/WriterInternals.h @@ -14,8 +14,8 @@ #include "llvm/Bytecode/Writer.h" #include "llvm/Bytecode/Format.h" -#include "llvm/Analysis/SlotCalculator.h" #include "llvm/Bytecode/Primitives.h" +#include "llvm/SlotCalculator.h" #include "llvm/Instruction.h" #include <deque> |