diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index c8e7b27..e843e5e 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -125,6 +125,7 @@
 global          { return GLOBAL; }
 constant        { return CONSTANT; }
 const           { return CONST; }
+internal        { return INTERNAL; }
 uninitialized   { return UNINIT; }
 implementation  { return IMPLEMENTATION; }
 \.\.\.          { return DOTDOTDOT; }
diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index fe422d0..0f25f54 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -174,7 +174,8 @@
 };
 
 struct MethPlaceHolderHelper : public Method {
-  MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty)) {}
+  MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty),
+						 true) {}
 };
 
 typedef PlaceholderValue<InstPlaceHolderHelper>  ValuePlaceHolder;
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index a74312b..aca9878 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -451,7 +451,7 @@
 // refering to the number can be resolved.  Do this now.
 //
 static void ResolveTypeTo(char *Name, const Type *ToTy) {
-  vector<PATypeHolder<Type> > &Types = inMethodScope ? 
+  vector<PATypeHolder<Type> > &Types = inMethodScope() ? 
      CurMeth.Types : CurModule.Types;
 
    ValID D;
@@ -684,7 +684,7 @@
 %type <ValueList>     IndexList                   // For GEP derived indices
 %type <TypeList>      TypeListI ArgTypeListI
 %type <JumpTable>     JumpTable
-%type <BoolVal>       GlobalType                  // GLOBAL or CONSTANT?
+%type <BoolVal>       GlobalType OptInternal      // GLOBAL or CONSTANT? Intern?
 
 // ValueRef - Unresolved reference to a definition or BB
 %type <ValIDVal>      ValueRef ConstValueRef SymbolicValueRef
@@ -715,7 +715,7 @@
 
 
 %token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE GLOBAL CONSTANT UNINIT
-%token TO EXCEPT DOTDOTDOT STRING NULL_TOK CONST
+%token TO EXCEPT DOTDOTDOT STRING NULL_TOK CONST INTERNAL
 
 // Basic Block Terminating Operators 
 %token <TermOpVal> RET BR SWITCH
@@ -780,6 +780,7 @@
     $$ = 0; 
   }
 
+OptInternal : INTERNAL { $$ = true; } | /*empty*/ { $$ = false; }
 
 //===----------------------------------------------------------------------===//
 // Types includes all predefined types... except void, because it can only be
@@ -987,7 +988,7 @@
 	// TODO: GlobalVariable here that includes the said information!
 	
 	// Create a placeholder for the global variable reference...
-	GlobalVariable *GV = new GlobalVariable(PT->getValueType(), false);
+	GlobalVariable *GV = new GlobalVariable(PT->getValueType(), false,true);
 	// Keep track of the fact that we have a forward ref to recycle it
 	CurModule.GlobalRefs.insert(make_pair(make_pair(PT, $2), GV));
 
@@ -1067,14 +1068,14 @@
   }
   | ConstPool MethodProto {            // Method prototypes can be in const pool
   }
-  | ConstPool OptAssign GlobalType ConstVal {
-    const Type *Ty = $4->getType();
+  | ConstPool OptAssign OptInternal GlobalType ConstVal {
+    const Type *Ty = $5->getType();
     // Global declarations appear in Constant Pool
-    ConstPoolVal *Initializer = $4;
+    ConstPoolVal *Initializer = $5;
     if (Initializer == 0)
       ThrowException("Global value initializer is not a constant!");
 	 
-    GlobalVariable *GV = new GlobalVariable(Ty, $3, Initializer);
+    GlobalVariable *GV = new GlobalVariable(Ty, $4, $3, Initializer);
     if (!setValueName(GV, $2)) {   // If not redefining...
       CurModule.CurrentModule->getGlobalList().push_back(GV);
       int Slot = InsertValue(GV, CurModule.Values);
@@ -1087,10 +1088,10 @@
       }
     }
   }
-  | ConstPool OptAssign UNINIT GlobalType Types {
-    const Type *Ty = *$5;
+  | ConstPool OptAssign OptInternal UNINIT GlobalType Types {
+    const Type *Ty = *$6;
     // Global declarations appear in Constant Pool
-    GlobalVariable *GV = new GlobalVariable(Ty, $4);
+    GlobalVariable *GV = new GlobalVariable(Ty, $5, $3);
     if (!setValueName(GV, $2)) {   // If not redefining...
       CurModule.CurrentModule->getGlobalList().push_back(GV);
       int Slot = InsertValue(GV, CurModule.Values);
@@ -1169,51 +1170,52 @@
     $$ = 0;
   }
 
-MethodHeaderH : TypesV STRINGCONSTANT '(' ArgList ')' {
-  UnEscapeLexed($2);
+MethodHeaderH : OptInternal TypesV STRINGCONSTANT '(' ArgList ')' {
+  UnEscapeLexed($3);
+  string MethodName($3);
+  
   vector<const Type*> ParamTypeList;
-  if ($4)
-    for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); ++I)
+  if ($5)
+    for (list<MethodArgument*>::iterator I = $5->begin(); I != $5->end(); ++I)
       ParamTypeList.push_back((*I)->getType());
 
   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
   if (isVarArg) ParamTypeList.pop_back();
 
-  const MethodType  *MT  = MethodType::get(*$1, ParamTypeList, isVarArg);
+  const MethodType  *MT  = MethodType::get(*$2, ParamTypeList, isVarArg);
   const PointerType *PMT = PointerType::get(MT);
-  delete $1;
+  delete $2;
 
   Method *M = 0;
   if (SymbolTable *ST = CurModule.CurrentModule->getSymbolTable()) {
-    if (Value *V = ST->lookup(PMT, $2)) {  // Method already in symtab?
+    if (Value *V = ST->lookup(PMT, MethodName)) {  // Method already in symtab?
       M = cast<Method>(V);
 
       // Yes it is.  If this is the case, either we need to be a forward decl,
       // or it needs to be.
       if (!CurMeth.isDeclare && !M->isExternal())
-	ThrowException("Redefinition of method '" + string($2) + "'!");      
+	ThrowException("Redefinition of method '" + MethodName + "'!");      
     }
   }
 
   if (M == 0) {  // Not already defined?
-    M = new Method(MT, $2);
+    M = new Method(MT, $1, MethodName);
     InsertValue(M, CurModule.Values);
-    CurModule.DeclareNewGlobalValue(M, ValID::create($2));
+    CurModule.DeclareNewGlobalValue(M, ValID::create($3));
   }
-
-  free($2);  // Free strdup'd memory!
+  free($3);  // Free strdup'd memory!
 
   CurMeth.MethodStart(M);
 
   // Add all of the arguments we parsed to the method...
-  if ($4 && !CurMeth.isDeclare) {        // Is null if empty...
+  if ($5 && !CurMeth.isDeclare) {        // Is null if empty...
     Method::ArgumentListType &ArgList = M->getArgumentList();
 
-    for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); ++I) {
+    for (list<MethodArgument*>::iterator I = $5->begin(); I != $5->end(); ++I) {
       InsertValue(*I);
       ArgList.push_back(*I);
     }
-    delete $4;                     // We're now done with the argument list
+    delete $5;                     // We're now done with the argument list
   }
 }