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 @@
 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 @@
 %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 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::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 @@
     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 @@
 //
 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::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 @@
     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 @@
   }
 
   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 @@
   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 @@
   // 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 @@
 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 @@
 // 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 @@
 //
 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());