[llvm-commits] CVS: llvm/lib/Transforms/Utils/CloneFunction.cpp CloneModule.cpp Linker.cpp

Chris Lattner lattner at cs.uiuc.edu
Wed Apr 16 15:29:05 PDT 2003


Changes in directory llvm/lib/Transforms/Utils:

CloneFunction.cpp updated: 1.14 -> 1.15
CloneModule.cpp updated: 1.1 -> 1.2
Linker.cpp updated: 1.37 -> 1.38

---
Log message:

Add new linkage types to support a real frontend


---
Diffs of the changes:

Index: llvm/lib/Transforms/Utils/CloneFunction.cpp
diff -u llvm/lib/Transforms/Utils/CloneFunction.cpp:1.14 llvm/lib/Transforms/Utils/CloneFunction.cpp:1.15
--- llvm/lib/Transforms/Utils/CloneFunction.cpp:1.14	Wed Nov 20 14:47:41 2002
+++ llvm/lib/Transforms/Utils/CloneFunction.cpp	Wed Apr 16 15:28:43 2003
@@ -110,7 +110,7 @@
                                     ArgTypes, F->getFunctionType()->isVarArg());
 
   // Create the new function...
-  Function *NewF = new Function(FTy, F->hasInternalLinkage(), F->getName());
+  Function *NewF = new Function(FTy, F->getLinkage(), F->getName());
   
   // Loop over the arguments, copying the names of the mapped arguments over...
   Function::aiterator DestI = NewF->abegin();


Index: llvm/lib/Transforms/Utils/CloneModule.cpp
diff -u llvm/lib/Transforms/Utils/CloneModule.cpp:1.1 llvm/lib/Transforms/Utils/CloneModule.cpp:1.2
--- llvm/lib/Transforms/Utils/CloneModule.cpp:1.1	Wed Nov 20 14:47:41 2002
+++ llvm/lib/Transforms/Utils/CloneModule.cpp	Wed Apr 16 15:28:43 2003
@@ -29,13 +29,14 @@
   // don't worry about attributes or initializers, they will come later.
   //
   for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
-    ValueMap[I] = new GlobalVariable(I->getType()->getElementType(),
-                                     false, false, 0, I->getName(), New);
+    ValueMap[I] = new GlobalVariable(I->getType()->getElementType(), false,
+                                     GlobalValue::ExternalLinkage, 0,
+                                     I->getName(), New);
 
   // Loop over the functions in the module, making external functions as before
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     ValueMap[I]=new Function(cast<FunctionType>(I->getType()->getElementType()),
-                             false, I->getName(), New);
+                             GlobalValue::ExternalLinkage, I->getName(), New);
 
   // Now that all of the things that global variable initializer can refer to
   // have been created, loop through and copy the global variable referrers
@@ -46,8 +47,7 @@
     if (I->hasInitializer())
       GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(),
                                                  ValueMap)));
-    if (I->hasInternalLinkage())
-      GV->setInternalLinkage(true);
+    GV->setLinkage(I->getLinkage());
   }
 
   // Similarly, copy over function bodies now...
@@ -65,8 +65,7 @@
       CloneFunctionInto(F, I, ValueMap, Returns);
     }
 
-    if (I->hasInternalLinkage())
-      F->setInternalLinkage(true);
+    F->setLinkage(I->getLinkage());
   }
 
   return New;


Index: llvm/lib/Transforms/Utils/Linker.cpp
diff -u llvm/lib/Transforms/Utils/Linker.cpp:1.37 llvm/lib/Transforms/Utils/Linker.cpp:1.38
--- llvm/lib/Transforms/Utils/Linker.cpp:1.37	Thu Jan 30 14:53:43 2003
+++ llvm/lib/Transforms/Utils/Linker.cpp	Wed Apr 16 15:28:43 2003
@@ -189,42 +189,48 @@
   //
   for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){
     const GlobalVariable *SGV = I;
-    Value *V;
-
-    // If the global variable has a name, and that name is already in use in the
-    // Dest module, make sure that the name is a compatible global variable...
-    //
-    if (SGV->hasExternalLinkage() && SGV->hasName() &&
-	(V = ST->lookup(SGV->getType(), SGV->getName())) &&
-	cast<GlobalVariable>(V)->hasExternalLinkage()) {
-      // The same named thing is a global variable, because the only two things
+    GlobalVariable *DGV = 0;
+    if (SGV->hasName()) {
+      // A same named thing is a global variable, because the only two things
       // that may be in a module level symbol table are Global Vars and
       // Functions, and they both have distinct, nonoverlapping, possible types.
       // 
-      GlobalVariable *DGV = cast<GlobalVariable>(V);
+      DGV = cast_or_null<GlobalVariable>(ST->lookup(SGV->getType(),
+                                                    SGV->getName()));
+    }
 
-      // Check to see if the two GV's have the same Const'ness...
-      if (SGV->isConstant() != DGV->isConstant())
-        return Error(Err, "Global Variable Collision on '" + 
-                     SGV->getType()->getDescription() + "':%" + SGV->getName() +
-                     " - Global variables differ in const'ness");
+    assert(SGV->hasInitializer() || SGV->hasExternalLinkage() &&
+           "Global must either be external or have an initializer!");
 
-      // Okay, everything is cool, remember the mapping...
-      ValueMap.insert(std::make_pair(SGV, DGV));
-    } else {
+    if (!DGV || DGV->hasInternalLinkage() || SGV->hasInternalLinkage()) {
       // No linking to be performed, simply create an identical version of the
       // symbol over in the dest module... the initializer will be filled in
       // later by LinkGlobalInits...
       //
-      GlobalVariable *DGV = 
-        new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(),
-                           SGV->hasInternalLinkage(), 0, SGV->getName());
-
-      // Add the new global to the dest module
-      Dest->getGlobalList().push_back(DGV);
+      DGV = new GlobalVariable(SGV->getType()->getElementType(),
+                               SGV->isConstant(), SGV->getLinkage(), /*init*/0,
+                               SGV->getName(), Dest);
 
       // Make sure to remember this mapping...
       ValueMap.insert(std::make_pair(SGV, DGV));
+    } else if (SGV->getLinkage() != DGV->getLinkage()) {
+      return Error(Err, "Global variables named '" + SGV->getName() +
+                   "' have different linkage specifiers!");
+    } else if (SGV->hasExternalLinkage() || SGV->hasLinkOnceLinkage() ||
+               SGV->hasAppendingLinkage()) {
+      // If the global variable has a name, and that name is already in use in
+      // the Dest module, make sure that the name is a compatible global
+      // variable...
+      //
+      // Check to see if the two GV's have the same Const'ness...
+      if (SGV->isConstant() != DGV->isConstant())
+        return Error(Err, "Global Variable Collision on '" + 
+                     SGV->getType()->getDescription() + "':%" + SGV->getName() +
+                     " - Global variables differ in const'ness");
+      // Okay, everything is cool, remember the mapping...
+      ValueMap.insert(std::make_pair(SGV, DGV));
+    } else {
+      assert(0 && "Unknown linkage!");
     }
   }
   return false;
@@ -245,19 +251,28 @@
 
     if (SGV->hasInitializer()) {      // Only process initialized GV's
       // Figure out what the initializer looks like in the dest module...
-      Constant *DInit =
+      Constant *SInit =
         cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap, 0));
 
       GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);    
-      if (DGV->hasInitializer() && SGV->hasExternalLinkage() &&
-	  DGV->hasExternalLinkage()) {
-        if (DGV->getInitializer() != DInit)
-          return Error(Err, "Global Variable Collision on '" + 
-                       SGV->getType()->getDescription() + "':%" +SGV->getName()+
-                       " - Global variables have different initializers");
+      if (DGV->hasInitializer()) {
+        assert(SGV->getLinkage() == DGV->getLinkage());
+        if (SGV->hasExternalLinkage()) {
+          if (DGV->getInitializer() != SInit)
+            return Error(Err, "Global Variable Collision on '" + 
+                         SGV->getType()->getDescription() +"':%"+SGV->getName()+
+                         " - Global variables have different initializers");
+        } else if (DGV->hasLinkOnceLinkage()) {
+          // Nothing is required, mapped values will take the new global
+          // automatically.
+        } else if (DGV->hasAppendingLinkage()) {
+          assert(0 && "Appending linkage unimplemented!");
+        } else {
+          assert(0 && "Unknown linkage!");
+        }
       } else {
         // Copy the initializer over now...
-        DGV->setInitializer(DInit);
+        DGV->setInitializer(SInit);
       }
     }
   }
@@ -278,39 +293,42 @@
   //
   for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
     const Function *SF = I;   // SrcFunction
-    Value *V;
-
-    // If the function has a name, and that name is already in use in the Dest
-    // module, make sure that the name is a compatible function...
-    //
-    if (SF->hasExternalLinkage() && SF->hasName() &&
-	(V = ST->lookup(SF->getType(), SF->getName())) &&
-	cast<Function>(V)->hasExternalLinkage()) {
+    Function *DF = 0;
+    if (SF->hasName())
       // The same named thing is a Function, because the only two things
       // that may be in a module level symbol table are Global Vars and
       // Functions, and they both have distinct, nonoverlapping, possible types.
       // 
-      Function *DF = cast<Function>(V);   // DestFunction
+      DF = cast_or_null<Function>(ST->lookup(SF->getType(), SF->getName()));
 
+    if (!DF || SF->hasInternalLinkage() || DF->hasInternalLinkage()) {
+      // Function does not already exist, simply insert an external function
+      // signature identical to SF into the dest module...
+      Function *DF = new Function(SF->getFunctionType(), SF->getLinkage(),
+                                  SF->getName(), Dest);
+
+      // ... and remember this mapping...
+      ValueMap.insert(std::make_pair(SF, DF));
+    } else if (SF->getLinkage() != DF->getLinkage()) {
+      return Error(Err, "Functions named '" + SF->getName() +
+                   "' have different linkage specifiers!");
+    } else if (SF->getLinkage() == GlobalValue::AppendingLinkage) {
+      return Error(Err, "Functions named '" + SF->getName() +
+                   "' have appending linkage!");
+    } else if (SF->getLinkage() == GlobalValue::ExternalLinkage) {
+      // If the function has a name, and that name is already in use in the Dest
+      // module, make sure that the name is a compatible function...
+      //
       // Check to make sure the function is not defined in both modules...
       if (!SF->isExternal() && !DF->isExternal())
         return Error(Err, "Function '" + 
                      SF->getFunctionType()->getDescription() + "':\"" + 
                      SF->getName() + "\" - Function is already defined!");
-
+      
       // Otherwise, just remember this mapping...
       ValueMap.insert(std::make_pair(SF, DF));
-    } else {
-      // Function does not already exist, simply insert an external function
-      // signature identical to SF into the dest module...
-      Function *DF = new Function(SF->getFunctionType(),
-                                  SF->hasInternalLinkage(),
-                                  SF->getName());
-
-      // Add the function signature to the dest module...
-      Dest->getFunctionList().push_back(DF);
-
-      // ... and remember this mapping...
+    } else if (SF->getLinkage() == GlobalValue::LinkOnceLinkage) {
+      // Completely ignore the source function.
       ValueMap.insert(std::make_pair(SF, DF));
     }
   }
@@ -391,6 +409,7 @@
 
       // DF not external SF external?
       if (!DF->isExternal()) {
+        if (DF->hasLinkOnceLinkage()) continue; // No relinkage for link-once!
         if (Err)
           *Err = "Function '" + (SF->hasName() ? SF->getName() :std::string(""))
                + "' body multiply defined!";





More information about the llvm-commits mailing list