aboutsummaryrefslogtreecommitdiff
path: root/lib/Bytecode
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Bytecode')
-rw-r--r--lib/Bytecode/Reader/Analyzer.cpp43
-rw-r--r--lib/Bytecode/Reader/Reader.cpp20
-rw-r--r--lib/Bytecode/Reader/Reader.h8
-rw-r--r--lib/Bytecode/Writer/SlotCalculator.cpp29
-rw-r--r--lib/Bytecode/Writer/SlotCalculator.h5
-rw-r--r--lib/Bytecode/Writer/Writer.cpp26
-rw-r--r--lib/Bytecode/Writer/WriterInternals.h3
7 files changed, 73 insertions, 61 deletions
diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp
index 64907a8e80..71cb4b2579 100644
--- a/lib/Bytecode/Reader/Analyzer.cpp
+++ b/lib/Bytecode/Reader/Analyzer.cpp
@@ -270,19 +270,15 @@ public:
*os << " } END BLOCK: CompactionTable\n";
}
- virtual void handleSymbolTableBegin(Function* CF, SymbolTable* ST) {
+ virtual void handleTypeSymbolTableBegin(TypeSymbolTable* ST) {
bca.numSymTab++;
if (os)
- *os << " BLOCK: SymbolTable {\n";
+ *os << " BLOCK: TypeSymbolTable {\n";
}
-
- virtual void handleSymbolTablePlane(unsigned Ty, unsigned NumEntries,
- const Type* Typ) {
- if (os) {
- *os << " Plane: Ty=" << Ty << " Size=" << NumEntries << " Type: ";
- WriteTypeSymbolic(*os,Typ,M);
- *os << "\n";
- }
+ virtual void handleValueSymbolTableBegin(Function* CF, ValueSymbolTable* ST) {
+ bca.numSymTab++;
+ if (os)
+ *os << " BLOCK: ValueSymbolTable {\n";
}
virtual void handleSymbolTableType(unsigned i, unsigned TypSlot,
@@ -292,18 +288,23 @@ public:
<< " Name: " << name << "\n";
}
- virtual void handleSymbolTableValue(unsigned i, unsigned ValSlot,
- const std::string& name ) {
+ virtual void handleSymbolTableValue(unsigned TySlot, unsigned ValSlot,
+ const std::string& name) {
if (os)
- *os << " Value " << i << " Slot=" << ValSlot
+ *os << " Value " << TySlot << " Slot=" << ValSlot
<< " Name: " << name << "\n";
if (ValSlot > bca.maxValueSlot)
bca.maxValueSlot = ValSlot;
}
- virtual void handleSymbolTableEnd() {
+ virtual void handleValueSymbolTableEnd() {
if (os)
- *os << " } END BLOCK: SymbolTable\n";
+ *os << " } END BLOCK: ValueSymbolTable\n";
+ }
+
+ virtual void handleTypeSymbolTableEnd() {
+ if (os)
+ *os << " } END BLOCK: TypeSymbolTable\n";
}
virtual void handleFunctionBegin(Function* Func, unsigned Size) {
@@ -358,15 +359,15 @@ public:
}
virtual bool handleInstruction( unsigned Opcode, const Type* iType,
- std::vector<unsigned>& Operands, unsigned Size){
+ std::vector<unsigned>& Operands,
+ Instruction *Inst,
+ unsigned Size){
if (os) {
*os << " INST: OpCode="
- << Instruction::getOpcodeName(Opcode) << " Type=\"";
- WriteTypeSymbolic(*os,iType,M);
- *os << "\"";
+ << Instruction::getOpcodeName(Opcode);
for ( unsigned i = 0; i < Operands.size(); ++i )
- *os << " Op(" << i << ")=Slot(" << Operands[i] << ")";
- *os << "\n";
+ *os << " Op(" << Operands[i] << ")";
+ *os << *Inst;
}
bca.numInstructions++;
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index e2505cc81e..ff6d8f04ca 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -23,7 +23,6 @@
#include "llvm/Constants.h"
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
-#include "llvm/SymbolTable.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/Bytecode/Format.h"
#include "llvm/Config/alloca.h"
@@ -55,6 +54,7 @@ namespace {
inline void BytecodeReader::error(const std::string& err) {
ErrorMsg = err + " (Vers=" + itostr(RevisionNum) + ", Pos="
+ itostr(At-MemStart) + ")";
+ if (Handler) Handler->handleError(ErrorMsg);
longjmp(context,1);
}
@@ -443,10 +443,6 @@ void BytecodeReader::ParseInstruction(std::vector<unsigned> &Oprnds,
// of opcodes.
Instruction* Result = 0;
- // We have enough info to inform the handler now.
- if (Handler)
- Handler->handleInstruction(Opcode, InstTy, Oprnds, At-SaveAt);
-
// First, handle the easy binary operators case
if (Opcode >= Instruction::BinaryOpsBegin &&
Opcode < Instruction::BinaryOpsEnd && Oprnds.size() == 2) {
@@ -861,6 +857,10 @@ void BytecodeReader::ParseInstruction(std::vector<unsigned> &Oprnds,
else
TypeSlot = getTypeSlot(Result->getType());
+ // We have enough info to inform the handler now.
+ if (Handler)
+ Handler->handleInstruction(Opcode, InstTy, Oprnds, Result, At-SaveAt);
+
insertValue(Result, TypeSlot, FunctionValues);
}
@@ -936,9 +936,9 @@ void BytecodeReader::ParseTypeSymbolTable(TypeSymbolTable *TST) {
/// CurrentFunction's symbol table. For Module level symbol tables, the
/// CurrentFunction argument must be zero.
void BytecodeReader::ParseValueSymbolTable(Function *CurrentFunction,
- SymbolTable *ST) {
+ ValueSymbolTable *VST) {
- if (Handler) Handler->handleSymbolTableBegin(CurrentFunction,ST);
+ if (Handler) Handler->handleValueSymbolTableBegin(CurrentFunction,VST);
// Allow efficient basic block lookup by number.
std::vector<BasicBlock*> BBMap;
@@ -963,13 +963,15 @@ void BytecodeReader::ParseValueSymbolTable(Function *CurrentFunction,
} else {
V = getValue(Typ, slot, false); // Find mapping...
}
+ if (Handler) Handler->handleSymbolTableValue(Typ, slot, Name);
if (V == 0)
- error("Failed value look-up for name '" + Name + "'");
+ error("Failed value look-up for name '" + Name + "', type #" +
+ utostr(Typ) + " slot #" + utostr(slot));
V->setName(Name);
}
}
checkPastBlockEnd("Symbol Table");
- if (Handler) Handler->handleSymbolTableEnd();
+ if (Handler) Handler->handleValueSymbolTableEnd();
}
// Parse a single type. The typeid is read in first. If its a primitive type
diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h
index 92c8fa0225..b881f9d0a5 100644
--- a/lib/Bytecode/Reader/Reader.h
+++ b/lib/Bytecode/Reader/Reader.h
@@ -28,8 +28,10 @@
namespace llvm {
-class BytecodeHandler; ///< Forward declare the handler interface
-class TypeSymbolTable; ///< Forward declare
+// Forward declarations
+class BytecodeHandler;
+class TypeSymbolTable;
+class ValueSymbolTable;
/// This class defines the interface for parsing a buffer of bytecode. The
/// parser itself takes no action except to call the various functions of
@@ -204,7 +206,7 @@ protected:
void ParseTypeSymbolTable(TypeSymbolTable *ST);
/// @brief Parse a value symbol table
- void ParseValueSymbolTable(Function* Func, SymbolTable *ST);
+ void ParseValueSymbolTable(Function* Func, ValueSymbolTable *ST);
/// @brief Parse functions lazily.
void ParseFunctionLazily();
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index 9115ddbc71..197f20601a 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -21,9 +21,9 @@
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/Type.h"
+#include "llvm/ValueSymbolTable.h"
#include "llvm/Analysis/ConstantsScanner.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/STLExtras.h"
@@ -218,8 +218,8 @@ void SlotCalculator::processModule() {
// processTypeSymbolTable - Insert all of the type sin the specified symbol
// table.
-void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *ST) {
- for (TypeSymbolTable::const_iterator TI = ST->begin(), TE = ST->end();
+void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *TST) {
+ for (TypeSymbolTable::const_iterator TI = TST->begin(), TE = TST->end();
TI != TE; ++TI )
getOrCreateSlot(TI->second);
}
@@ -227,23 +227,18 @@ void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *ST) {
// processSymbolTable - Insert all of the values in the specified symbol table
// into the values table...
//
-void SlotCalculator::processValueSymbolTable(const SymbolTable *ST) {
- for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
- PE = ST->plane_end(); PI != PE; ++PI)
- for (SymbolTable::value_const_iterator VI = PI->second.begin(),
- VE = PI->second.end(); VI != VE; ++VI)
- getOrCreateSlot(VI->second);
+void SlotCalculator::processValueSymbolTable(const ValueSymbolTable *VST) {
+ for (ValueSymbolTable::const_iterator VI = VST->begin(), VE = VST->end();
+ VI != VE; ++VI)
+ getOrCreateSlot(VI->second);
}
-void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
+void SlotCalculator::processSymbolTableConstants(const ValueSymbolTable *VST) {
// Now do the constant values in all planes
- for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
- PE = ST->plane_end(); PI != PE; ++PI)
- for (SymbolTable::value_const_iterator VI = PI->second.begin(),
- VE = PI->second.end(); VI != VE; ++VI)
- if (isa<Constant>(VI->second) &&
- !isa<GlobalValue>(VI->second))
- getOrCreateSlot(VI->second);
+ for (ValueSymbolTable::const_iterator VI = VST->begin(), VE = VST->end();
+ VI != VE; ++VI)
+ if (isa<Constant>(VI->second) && !isa<GlobalValue>(VI->second))
+ getOrCreateSlot(VI->second);
}
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
index 820099273b..6cddb30f99 100644
--- a/lib/Bytecode/Writer/SlotCalculator.h
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -31,6 +31,7 @@ class Module;
class Function;
class SymbolTable;
class TypeSymbolTable;
+class ValueSymbolTable;
class ConstantArray;
class SlotCalculator {
@@ -130,8 +131,8 @@ private:
// into the values table...
//
void processTypeSymbolTable(const TypeSymbolTable *ST);
- void processValueSymbolTable(const SymbolTable *ST);
- void processSymbolTableConstants(const SymbolTable *ST);
+ void processValueSymbolTable(const ValueSymbolTable *ST);
+ void processSymbolTableConstants(const ValueSymbolTable *ST);
// insertPrimitives - helper for constructors to insert primitive types.
void insertPrimitives();
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 0d4ccbddd6..a2e8fe566d 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -26,8 +26,8 @@
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
#include "llvm/TypeSymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/Compressor.h"
#include "llvm/Support/MathExtras.h"
@@ -1144,21 +1144,31 @@ void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) {
}
}
-void BytecodeWriter::outputValueSymbolTable(const SymbolTable &MST) {
+void BytecodeWriter::outputValueSymbolTable(const ValueSymbolTable &VST) {
// Do not output the Bytecode block for an empty symbol table, it just wastes
// space!
- if (MST.isEmpty()) return;
+ if (VST.empty()) return;
BytecodeBlock SymTabBlock(BytecodeFormat::ValueSymbolTableBlockID, *this,
true/*ElideIfEmpty*/);
- // Now do each of the type planes in order.
- for (SymbolTable::plane_const_iterator PI = MST.plane_begin(),
- PE = MST.plane_end(); PI != PE; ++PI) {
- SymbolTable::value_const_iterator I = MST.value_begin(PI->first);
- SymbolTable::value_const_iterator End = MST.value_end(PI->first);
+ // Organize the symbol table by type
+ typedef std::pair<std::string, const Value*> PlaneMapEntry;
+ typedef std::vector<PlaneMapEntry> PlaneMapVector;
+ typedef std::map<const Type*, PlaneMapVector > PlaneMap;
+ PlaneMap Planes;
+ for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
+ SI != SE; ++SI)
+ Planes[SI->second->getType()].push_back(
+ std::make_pair(SI->first,SI->second));
+
+ for (PlaneMap::const_iterator PI = Planes.begin(), PE = Planes.end();
+ PI != PE; ++PI) {
int Slot;
+ PlaneMapVector::const_iterator I = PI->second.begin();
+ PlaneMapVector::const_iterator End = PI->second.end();
+
if (I == End) continue; // Don't mess with an absent type...
// Write the number of values in this plane
diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h
index c518c01b94..f3c59f3288 100644
--- a/lib/Bytecode/Writer/WriterInternals.h
+++ b/lib/Bytecode/Writer/WriterInternals.h
@@ -26,6 +26,7 @@
namespace llvm {
class InlineAsm;
class TypeSymbolTable;
+ class ValueSymbolTable;
class BytecodeWriter {
std::vector<unsigned char> &Out;
@@ -66,7 +67,7 @@ private:
void outputModuleInfoBlock(const Module *C);
void outputTypeSymbolTable(const TypeSymbolTable &TST);
- void outputValueSymbolTable(const SymbolTable &ST);
+ void outputValueSymbolTable(const ValueSymbolTable &ST);
void outputTypes(unsigned StartNo);
void outputConstantsInPlane(const std::vector<const Value*> &Plane,
unsigned StartNo);
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-04-28 16:28:43 +0000