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:
--- /dev/null
+//===-- 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
#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:
// 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(); }
class Instruction;
class BasicBlock;
class Method;
+class GlobalVariable;
class Module;
class SymbolTable;
template<class ValueSubclass, class ItemParentType, class SymTabType>
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
};
CAST_FN(Instruction , Instruction )
CAST_FN(BasicBlock , BasicBlock )
CAST_FN(Method , Method )
+ CAST_FN(Global , GlobalVariable)
CAST_FN(Module , Module )
#undef CAST_FN
true { return TRUE; }
false { return FALSE; }
declare { return DECLARE; }
+global { return GLOBAL; }
implementation { return IMPLEMENTATION; }
\.\.\. { return DOTDOTDOT; }
string { return STRING; }
%{
#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
%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
}
| 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 */ {
}
#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"
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;
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);
}
#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"
//
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());
#include "WriterInternals.h"
#include "llvm/Module.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstPoolVals.h"
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!");
output_vbr((unsigned)Slot, Out);
}
output_vbr((unsigned)Table.getValSlot(Type::VoidTy), Out);
+
+
align32(Out);
}
#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"
}
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); }
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);
};
// 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...
//===-- 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.
//
//===----------------------------------------------------------------------===//
#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! :(
//
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);
+}
#include "llvm/Module.h"
#include "llvm/Method.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/BasicBlock.h"
#include "llvm/InstrTypes.h"
#include "llvm/ValueHolderImpl.h"
// 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);
}
// 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);
}
#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"
//
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());
--- /dev/null
+
+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
+
projects / oota-llvm.git / commitdiff