We need to propagate the debug location information even when dealing with the

[oota-llvm.git] / lib / VMCore / Module.cpp

diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index b95f6e3fa8661fd2a95773ebe7a260a465394234..896245d69e6754cb2b21cb9304f7b164fcc00c05 100644 (file)
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -137,7 +137,8 @@ Module::PointerSize Module::getPointerSize() const {
 // the symbol table directly for this common task.
 //
 Constant *Module::getOrInsertFunction(const std::string &Name,
-                                      const FunctionType *Ty) {
+                                      const FunctionType *Ty,
+                                      AttrListPtr AttributeList) {
   ValueSymbolTable &SymTab = getValueSymbolTable();
 
   // See if we have a definition for the specified function already.
@@ -145,12 +146,14 @@ Constant *Module::getOrInsertFunction(const std::string &Name,
   if (F == 0) {
     // Nope, add it
     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
+    if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
+      New->setAttributes(AttributeList);
     FunctionList.push_back(New);
     return New;                    // Return the new prototype.
   }
 
   // Okay, the function exists.  Does it have externally visible linkage?
-  if (F->hasInternalLinkage()) {
+  if (F->hasLocalLinkage()) {
     // Clear the function's name.
     F->setName("");
     // Retry, now there won't be a conflict.
@@ -168,12 +171,38 @@ Constant *Module::getOrInsertFunction(const std::string &Name,
   return F;  
 }
 
+Constant *Module::getOrInsertTargetIntrinsic(const std::string &Name,
+                                             const FunctionType *Ty,
+                                             AttrListPtr AttributeList) {
+  ValueSymbolTable &SymTab = getValueSymbolTable();
+
+  // See if we have a definition for the specified function already.
+  GlobalValue *F = dyn_cast_or_null<GlobalValue>(SymTab.lookup(Name));
+  if (F == 0) {
+    // Nope, add it
+    Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
+    New->setAttributes(AttributeList);
+    FunctionList.push_back(New);
+    return New; // Return the new prototype.
+  }
+
+  // Otherwise, we just found the existing function or a prototype.
+  return F;  
+}
+
+Constant *Module::getOrInsertFunction(const std::string &Name,
+                                      const FunctionType *Ty) {
+  AttrListPtr AttributeList = AttrListPtr::get((AttributeWithIndex *)0, 0);
+  return getOrInsertFunction(Name, Ty, AttributeList);
+}
+
 // getOrInsertFunction - Look up the specified function in the module symbol
 // table.  If it does not exist, add a prototype for the function and return it.
 // This version of the method takes a null terminated list of function
 // arguments, which makes it easier for clients to use.
 //
 Constant *Module::getOrInsertFunction(const std::string &Name,
+                                      AttrListPtr AttributeList,
                                       const Type *RetTy, ...) {
   va_list Args;
   va_start(Args, RetTy);
@@ -186,9 +215,26 @@ Constant *Module::getOrInsertFunction(const std::string &Name,
   va_end(Args);
 
   // Build the function type and chain to the other getOrInsertFunction...
-  return getOrInsertFunction(Name, FunctionType::get(RetTy, ArgTys, false));
+  return getOrInsertFunction(Name, FunctionType::get(RetTy, ArgTys, false),
+                             AttributeList);
 }
 
+Constant *Module::getOrInsertFunction(const std::string &Name,
+                                      const Type *RetTy, ...) {
+  va_list Args;
+  va_start(Args, RetTy);
+
+  // Build the list of argument types...
+  std::vector<const Type*> ArgTys;
+  while (const Type *ArgTy = va_arg(Args, const Type*))
+    ArgTys.push_back(ArgTy);
+
+  va_end(Args);
+
+  // Build the function type and chain to the other getOrInsertFunction...
+  return getOrInsertFunction(Name, FunctionType::get(RetTy, ArgTys, false),
+                             AttrListPtr::get((AttributeWithIndex *)0, 0));
+}
 
 // getFunction - Look up the specified function in the module symbol table.
 // If it does not exist, return null.
@@ -211,19 +257,47 @@ Function *Module::getFunction(const char *Name) const {
 /// symbol table.  If it does not exist, return null.  The type argument
 /// should be the underlying type of the global, i.e., it should not have
 /// the top-level PointerType, which represents the address of the global.
-/// If AllowInternal is set to true, this function will return types that
-/// have InternalLinkage. By default, these types are not returned.
+/// If AllowLocal is set to true, this function will return types that
+/// have an local. By default, these types are not returned.
 ///
 GlobalVariable *Module::getGlobalVariable(const std::string &Name,
-                                          bool AllowInternal) const {
+                                          bool AllowLocal) const {
   if (Value *V = ValSymTab->lookup(Name)) {
     GlobalVariable *Result = dyn_cast<GlobalVariable>(V);
-    if (Result && (AllowInternal || !Result->hasInternalLinkage()))
+    if (Result && (AllowLocal || !Result->hasLocalLinkage()))
       return Result;
   }
   return 0;
 }
 
+/// getOrInsertGlobal - Look up the specified global in the module symbol table.
+///   1. If it does not exist, add a declaration of the global and return it.
+///   2. Else, the global exists but has the wrong type: return the function
+///      with a constantexpr cast to the right type.
+///   3. Finally, if the existing global is the correct delclaration, return the
+///      existing global.
+Constant *Module::getOrInsertGlobal(const std::string &Name, const Type *Ty) {
+  ValueSymbolTable &SymTab = getValueSymbolTable();
+
+  // See if we have a definition for the specified global already.
+  GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(SymTab.lookup(Name));
+  if (GV == 0) {
+    // Nope, add it
+    GlobalVariable *New =
+      new GlobalVariable(Ty, false, GlobalVariable::ExternalLinkage, 0, Name);
+    GlobalList.push_back(New);
+    return New;                    // Return the new declaration.
+  }
+
+  // If the variable exists but has the wrong type, return a bitcast to the
+  // right type.
+  if (GV->getType() != PointerType::getUnqual(Ty))
+    return ConstantExpr::getBitCast(GV, PointerType::getUnqual(Ty));
+  
+  // Otherwise, we just found the existing function or a prototype.
+  return GV;
+}
+
 //===----------------------------------------------------------------------===//
 // Methods for easy access to the global variables in the module.
 //
@@ -321,4 +395,3 @@ void Module::removeLibrary(const std::string& Lib) {
       return;
     }
 }
-