aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/llvm/Function.h2
-rw-r--r--include/llvm/GlobalVariable.h34
-rw-r--r--include/llvm/Module.h37
-rw-r--r--include/llvm/Value.h4
-rw-r--r--lib/AsmParser/Lexer.l1
-rw-r--r--lib/AsmParser/llvmAsmParser.y32
-rw-r--r--lib/Bytecode/Reader/Reader.cpp22
-rw-r--r--lib/Bytecode/Writer/SlotCalculator.cpp15
-rw-r--r--lib/Bytecode/Writer/Writer.cpp13
-rw-r--r--lib/VMCore/AsmWriter.cpp16
-rw-r--r--lib/VMCore/Function.cpp31
-rw-r--r--lib/VMCore/Module.cpp12
-rw-r--r--lib/VMCore/SlotCalculator.cpp15
-rw-r--r--test/Feature/globalvars.ll14
14 files changed, 219 insertions, 29 deletions
diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index b1d38dd..2be84d4 100644
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -40,7 +40,7 @@ private:
Module *Parent; // The module that contains this method
- friend class ValueHolder<Method,Module, Module>;
+ friend class ValueHolder<Method, Module, Module>;
void setParent(Module *parent);
public:
diff --git a/include/llvm/GlobalVariable.h b/include/llvm/GlobalVariable.h
new file mode 100644
index 0000000..fd97989
--- /dev/null
+++ b/include/llvm/GlobalVariable.h
@@ -0,0 +1,34 @@
+//===-- llvm/Global.h - Class to represent a global variable -----*- C++ -*--=//
+//
+// This file contains the declaration of the GlobalVariable class, which
+// represents a single global variable in the VM.
+//
+// Global variables are constant pointers that refer to hunks of space that are
+// allocated by either the VM, or by the linker in a static compiler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_GLOBAL_VARIABLE_H
+#define LLVM_GLOBAL_VARIABLE_H
+
+#include "llvm/Value.h"
+class Module;
+
+class GlobalVariable : public Value {
+ Module *Parent; // The module that contains this method
+
+ friend class ValueHolder<GlobalVariable, Module, Module>;
+ void setParent(Module *parent) { Parent = parent; }
+
+public:
+ GlobalVariable(const Type *Ty, const string &Name = "");
+ ~GlobalVariable() {}
+
+ // Specialize setName to handle symbol table majik...
+ virtual void setName(const string &name, SymbolTable *ST = 0);
+
+ inline Module *getParent() { return Parent; }
+ inline const Module *getParent() const { return Parent; }
+};
+
+#endif
diff --git a/include/llvm/Module.h b/include/llvm/Module.h
index 866f5e0..bf710d1 100644
--- a/include/llvm/Module.h
+++ b/include/llvm/Module.h
@@ -12,17 +12,27 @@
#include "llvm/SymTabValue.h"
#include "llvm/ValueHolder.h"
class Method;
+class GlobalVariable;
class Module : public Value, public SymTabValue {
public:
+ typedef ValueHolder<GlobalVariable, Module, Module> GlobalListType;
typedef ValueHolder<Method, Module, Module> MethodListType;
+ // Global Variable iterators...
+ typedef GlobalListType::iterator giterator;
+ typedef GlobalListType::const_iterator const_giterator;
+ typedef reverse_iterator<giterator> reverse_giterator;
+ typedef reverse_iterator<const_giterator> const_reverse_giterator;
+
// Method iterators...
- typedef MethodListType::iterator iterator;
- typedef MethodListType::const_iterator const_iterator;
+ typedef MethodListType::iterator iterator;
+ typedef MethodListType::const_iterator const_iterator;
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
+
private:
+ GlobalListType GlobalList; // The Global Variables
MethodListType MethodList; // The Methods
public:
@@ -32,17 +42,40 @@ public:
// reduceApply - Apply the specified function to all of the methods in this
// module. The result values are or'd together and the result is returned.
//
+ bool reduceApply(bool (*Func)(GlobalVariable*));
+ bool reduceApply(bool (*Func)(const GlobalVariable*)) const;
bool reduceApply(bool (*Func)(Method*));
bool reduceApply(bool (*Func)(const Method*)) const;
// Get the underlying elements of the Module...
+ inline const GlobalListType &getGlobalList() const { return GlobalList; }
+ inline GlobalListType &getGlobalList() { return GlobalList; }
inline const MethodListType &getMethodList() const { return MethodList; }
inline MethodListType &getMethodList() { return MethodList; }
//===--------------------------------------------------------------------===//
// Module iterator forwarding functions
//
+ inline giterator gbegin() { return GlobalList.begin(); }
+ inline const_giterator gbegin() const { return GlobalList.begin(); }
+ inline giterator gend () { return GlobalList.end(); }
+ inline const_giterator gend () const { return GlobalList.end(); }
+
+ inline reverse_giterator grbegin() { return GlobalList.rbegin(); }
+ inline const_reverse_giterator grbegin() const { return GlobalList.rbegin(); }
+ inline reverse_giterator grend () { return GlobalList.rend(); }
+ inline const_reverse_giterator grend () const { return GlobalList.rend(); }
+
+ inline unsigned gsize() const { return GlobalList.size(); }
+ inline bool gempty() const { return GlobalList.empty(); }
+ inline const GlobalVariable *gfront() const { return GlobalList.front(); }
+ inline GlobalVariable *gfront() { return GlobalList.front(); }
+ inline const GlobalVariable *gback() const { return GlobalList.back(); }
+ inline GlobalVariable *gback() { return GlobalList.back(); }
+
+
+
inline iterator begin() { return MethodList.begin(); }
inline const_iterator begin() const { return MethodList.begin(); }
inline iterator end () { return MethodList.end(); }
diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index 889551d..dd97d35 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -19,6 +19,7 @@ class MethodArgument;
class Instruction;
class BasicBlock;
class Method;
+class GlobalVariable;
class Module;
class SymbolTable;
template<class ValueSubclass, class ItemParentType, class SymTabType>
@@ -36,9 +37,9 @@ public:
ConstantVal, // This is an instance of ConstPoolVal
MethodArgumentVal, // This is an instance of MethodArgument
InstructionVal, // This is an instance of Instruction
-
BasicBlockVal, // This is an instance of BasicBlock
MethodVal, // This is an instance of Method
+ GlobalVal, // This is an instance of GlobalVariable
ModuleVal, // This is an instance of Module
};
@@ -102,6 +103,7 @@ public:
CAST_FN(Instruction , Instruction )
CAST_FN(BasicBlock , BasicBlock )
CAST_FN(Method , Method )
+ CAST_FN(Global , GlobalVariable)
CAST_FN(Module , Module )
#undef CAST_FN
diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 9c3f947..6a650a3 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -122,6 +122,7 @@ end { return END; }
true { return TRUE; }
false { return FALSE; }
declare { return DECLARE; }
+global { return GLOBAL; }
implementation { return IMPLEMENTATION; }
\.\.\. { return DOTDOTDOT; }
string { return STRING; }
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 9971050..0568b33 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -12,13 +12,13 @@
%{
#include "ParserInternals.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
+#include "llvm/Assembly/Parser.h"
#include "llvm/SymbolTable.h"
#include "llvm/Module.h"
-#include "llvm/Type.h"
+#include "llvm/GlobalVariable.h"
+#include "llvm/Method.h"
+#include "llvm/BasicBlock.h"
#include "llvm/DerivedTypes.h"
-#include "llvm/Assembly/Parser.h"
#include "llvm/iTerminators.h"
#include "llvm/iMemory.h"
#include "llvm/CFG.h" // TODO: Change this when we have a DF.h
@@ -568,7 +568,7 @@ Module *RunVMAsmParser(const string &Filename, FILE *F) {
%type <StrVal> OptVAR_ID OptAssign
-%token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE TO DOTDOTDOT STRING
+%token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE GLOBAL TO DOTDOTDOT STRING
// Basic Block Terminating Operators
%token <TermOpVal> RET BR SWITCH
@@ -871,15 +871,23 @@ ConstPool : ConstPool OptAssign ConstVal {
}
| ConstPool MethodProto { // Method prototypes can be in const pool
}
-/*
- | ConstPool OptAssign GlobalDecl { // Global declarations appear in CP
- if ($2) {
- setValueName($3, $2);
- free($2);
+ | ConstPool GLOBAL OptAssign Types { // Global declarations appear in CP
+ if (!$4->get()->isPointerType() ||
+ (((PointerType*)$4->get())->isArrayType() &&
+ ((PointerType*)$4->get())->isArrayType()->isUnsized())) {
+ ThrowException("Type '" + $4->get()->getDescription() +
+ "' is not a pointer to a sized type!");
}
- //CurModule.CurrentModule->
+
+ GlobalVariable *GV = new GlobalVariable(*$4);
+ delete $4;
+ if ($3) {
+ setValueName(GV, $3);
+ free($3);
+ }
+ CurModule.CurrentModule->getGlobalList().push_back(GV);
+ InsertValue(GV, CurModule.Values);
}
-*/
| /* empty: end of list */ {
}
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index 5407683..eab576e 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -12,6 +12,7 @@
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/Format.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/Module.h"
#include "llvm/BasicBlock.h"
#include "llvm/DerivedTypes.h"
@@ -312,10 +313,28 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
Module *C) {
-
if (!MethodSignatureList.empty())
return failure(true); // Two ModuleGlobal blocks?
+ // Read global variables...
+ unsigned VarType;
+ if (read_vbr(Buf, End, VarType)) return failure(true);
+ while (VarType != Type::VoidTyID) { // List is terminated by Void
+ const Type *Ty = getType(VarType);
+ if (!Ty || !Ty->isPointerType()) {
+ cerr << "Global not pointer type! Ty = " << Ty << endl;
+ return failure(true);
+ }
+
+ // Create the global variable...
+ GlobalVariable *GV = new GlobalVariable(Ty);
+ insertValue(GV, ModuleValues);
+ C->getGlobalList().push_back(GV);
+
+ if (read_vbr(Buf, End, VarType)) return failure(true);
+ BCR_TRACE(2, "Global Variable of type: " << Ty->getDescription() << endl);
+ }
+
// Read the method signatures for all of the methods that are coming, and
// create fillers in the Value tables.
unsigned MethSignature;
@@ -324,7 +343,6 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
const Type *Ty = getType(MethSignature);
if (!Ty || !Ty->isMethodType()) {
cerr << "Method not meth type! Ty = " << Ty << endl;
- if (Ty) cerr << Ty->getName(); else cerr << MethSignature; cerr << endl;
return failure(true);
}
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index 9af5a38..cc7d4e5 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -12,6 +12,7 @@
#include "llvm/Analysis/SlotCalculator.h"
#include "llvm/Analysis/ConstantsScanner.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/Module.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstPoolVals.h"
@@ -68,13 +69,21 @@ SlotCalculator::SlotCalculator(const Method *M, bool IgnoreNamed) {
//
void SlotCalculator::processModule() {
SC_DEBUG("begin processModule!\n");
- // Currently, the only module level declarations are methods and method
- // prototypes. We simply scavenge the types out of the methods, then add the
- // methods themselves to the value table...
+
+ // Add all of the global variables to the value table...
+ //
+ for_each(TheModule->gbegin(), TheModule->gend(),
+ bind_obj(this, &SlotCalculator::insertValue));
+
+ // Scavenge the types out of the methods, then add the methods themselves to
+ // the value table...
//
for_each(TheModule->begin(), TheModule->end(), // Insert methods...
bind_obj(this, &SlotCalculator::insertValue));
+ // Insert constants that are named at module level into the slot pool so that
+ // the module symbol table can refer to them...
+ //
if (TheModule->hasSymbolTable() && !IgnoreNamedNodes) {
SC_DEBUG("Inserting SymbolTable values:\n");
processSymbolTable(TheModule->getSymbolTable());
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 4235145..e6562f5 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -24,6 +24,7 @@
#include "WriterInternals.h"
#include "llvm/Module.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstPoolVals.h"
@@ -117,7 +118,15 @@ void BytecodeWriter::outputConstants(bool isMethod) {
void BytecodeWriter::outputModuleInfoBlock(const Module *M) {
BytecodeBlock ModuleInfoBlock(BytecodeFormat::ModuleGlobalInfo, Out);
- // Output the types of the methods in this class
+ // Output the types for the global variables in the module...
+ for (Module::const_giterator I = M->gbegin(), End = M->gend(); I != End;++I) {
+ int Slot = Table.getValSlot((*I)->getType());
+ assert(Slot != -1 && "Module global vars is broken!");
+ output_vbr((unsigned)Slot, Out);
+ }
+ output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out);
+
+ // Output the types of the methods 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!");
@@ -125,6 +134,8 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) {
output_vbr((unsigned)Slot, Out);
}
output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out);
+
+
align32(Out);
}
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index a8951e6..9056865 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -14,6 +14,7 @@
#include "llvm/Analysis/SlotCalculator.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstPoolVals.h"
#include "llvm/iOther.h"
@@ -81,6 +82,7 @@ public:
}
inline void write(const Module *M) { processModule(M); }
+ inline void write(const GlobalVariable *G) { processGlobal(G); }
inline void write(const Method *M) { processMethod(M); }
inline void write(const BasicBlock *BB) { processBasicBlock(BB); }
inline void write(const Instruction *I) { processInstruction(I); }
@@ -90,11 +92,12 @@ private :
void processModule(const Module *M);
void processSymbolTable(const SymbolTable &ST);
void processConstant(const ConstPoolVal *CPV);
+ void processGlobal(const GlobalVariable *GV);
void processMethod(const Method *M);
void processMethodArgument(const MethodArgument *MA);
void processBasicBlock(const BasicBlock *BB);
void processInstruction(const Instruction *I);
-
+
void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
};
@@ -109,13 +112,22 @@ void AssemblyWriter::processModule(const Module *M) {
// Loop over the symbol table, emitting all named constants...
if (M->hasSymbolTable())
processSymbolTable(*M->getSymbolTable());
-
+
+ for_each(M->gbegin(), M->gend(),
+ bind_obj(this, &AssemblyWriter::processGlobal));
+
Out << "implementation\n";
// Output all of the methods...
for_each(M->begin(), M->end(), bind_obj(this,&AssemblyWriter::processMethod));
}
+void AssemblyWriter::processGlobal(const GlobalVariable *GV) {
+ Out << "global ";
+ if (GV->hasName()) Out << "%" << GV->getName() << " = ";
+ Out << GV->getType()->getDescription() << endl;
+}
+
// processSymbolTable - Run through symbol table looking for named constants
// if a named constant is found, emit it's declaration...
diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index bd342a2..0ec6411 100644
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -1,6 +1,7 @@
//===-- Method.cpp - Implement the Method class ------------------*- C++ -*--=//
//
-// This file implements the Method class for the VMCore library.
+// This file implements the Method & GlobalVariable classes for the VMCore
+// library.
//
//===----------------------------------------------------------------------===//
@@ -9,9 +10,15 @@
#include "llvm/SymbolTable.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/BasicBlock.h"
#include "llvm/iOther.h"
+//===----------------------------------------------------------------------===//
+// Method Implementation
+//===----------------------------------------------------------------------===//
+
+
// Instantiate Templates - This ugliness is the price we have to pay
// for having a ValueHolderImpl.h file seperate from ValueHolder.h! :(
//
@@ -74,3 +81,25 @@ const MethodType *Method::getMethodType() const {
void Method::dropAllReferences() {
for_each(begin(), end(), std::mem_fun(&BasicBlock::dropAllReferences));
}
+
+//===----------------------------------------------------------------------===//
+// GlobalVariable Implementation
+//===----------------------------------------------------------------------===//
+
+GlobalVariable::GlobalVariable(const Type *Ty, const string &Name = "")
+ : Value(Ty, Value::GlobalVal, Name), Parent(0) {
+ assert(Ty->isPointerType() &&
+ (!Ty->isPointerType()->isArrayType() || // No unsized array pointers
+ Ty->isPointerType()->isArrayType()->isSized()) &&
+ "Global Variables must be pointers to a sized type!");
+}
+
+// Specialize setName to take care of symbol table majik
+void GlobalVariable::setName(const string &name, SymbolTable *ST) {
+ Module *P;
+ assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) &&
+ "Invalid symtab argument!");
+ if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this);
+ Value::setName(name);
+ if (P && getName() != "") P->getSymbolTableSure()->insert(this);
+}
diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index 4ab8bb0..5fc11d1 100644
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -6,6 +6,7 @@
#include "llvm/Module.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/BasicBlock.h"
#include "llvm/InstrTypes.h"
#include "llvm/ValueHolderImpl.h"
@@ -15,15 +16,18 @@
// Instantiate Templates - This ugliness is the price we have to pay
// for having a DefHolderImpl.h file seperate from DefHolder.h! :(
//
+template class ValueHolder<GlobalVariable, Module, Module>;
template class ValueHolder<Method, Module, Module>;
Module::Module()
: Value(Type::VoidTy, Value::ModuleVal, ""), SymTabValue(this),
- MethodList(this, this) {
+ GlobalList(this, this), MethodList(this, this) {
}
Module::~Module() {
dropAllReferences();
+ GlobalList.delete_all();
+ GlobalList.setParent(0);
MethodList.delete_all();
MethodList.setParent(0);
}
@@ -46,6 +50,12 @@ void Module::dropAllReferences() {
// reduceApply - Apply the specified function to all of the methods in this
// module. The result values are or'd together and the result is returned.
//
+bool Module::reduceApply(bool (*Func)(GlobalVariable*)) {
+ return reduce_apply_bool(gbegin(), gend(), Func);
+}
+bool Module::reduceApply(bool (*Func)(const GlobalVariable*)) const {
+ return reduce_apply_bool(gbegin(), gend(), Func);
+}
bool Module::reduceApply(bool (*Func)(Method*)) {
return reduce_apply_bool(begin(), end(), Func);
}
diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp
index 9af5a38..cc7d4e5 100644
--- a/lib/VMCore/SlotCalculator.cpp
+++ b/lib/VMCore/SlotCalculator.cpp
@@ -12,6 +12,7 @@
#include "llvm/Analysis/SlotCalculator.h"
#include "llvm/Analysis/ConstantsScanner.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/Module.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstPoolVals.h"
@@ -68,13 +69,21 @@ SlotCalculator::SlotCalculator(const Method *M, bool IgnoreNamed) {
//
void SlotCalculator::processModule() {
SC_DEBUG("begin processModule!\n");
- // Currently, the only module level declarations are methods and method
- // prototypes. We simply scavenge the types out of the methods, then add the
- // methods themselves to the value table...
+
+ // Add all of the global variables to the value table...
+ //
+ for_each(TheModule->gbegin(), TheModule->gend(),
+ bind_obj(this, &SlotCalculator::insertValue));
+
+ // Scavenge the types out of the methods, then add the methods themselves to
+ // the value table...
//
for_each(TheModule->begin(), TheModule->end(), // Insert methods...
bind_obj(this, &SlotCalculator::insertValue));
+ // Insert constants that are named at module level into the slot pool so that
+ // the module symbol table can refer to them...
+ //
if (TheModule->hasSymbolTable() && !IgnoreNamedNodes) {
SC_DEBUG("Inserting SymbolTable values:\n");
processSymbolTable(TheModule->getSymbolTable());
diff --git a/test/Feature/globalvars.ll b/test/Feature/globalvars.ll
new file mode 100644
index 0000000..ef3f336
--- /dev/null
+++ b/test/Feature/globalvars.ll
@@ -0,0 +1,14 @@
+
+global %MyVar = int *
+global %MyIntList = { \2 *, int } *
+global int * ; int*:0
+
+implementation
+
+int "foo"(int %blah)
+begin
+ store int 5, int *%MyVar
+ store int 12, { \2 *, int } * %MyIntList, ubyte 1
+ ret int %blah
+end
+
generated by cgit v1.1 at 2025-02-04 22:06:11 +0000