//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include <algorithm>
#include <cstdarg>
#include <cstdlib>
-#include <map>
using namespace llvm;
//===----------------------------------------------------------------------===//
Function *ilist_traits<Function>::createSentinel() {
FunctionType *FTy =
FunctionType::get(Type::VoidTy, std::vector<const Type*>(), false);
- Function *Ret = new Function(FTy, GlobalValue::ExternalLinkage);
+ Function *Ret = Function::Create(FTy, GlobalValue::ExternalLinkage);
// This should not be garbage monitored.
LeakDetector::removeGarbageObject(Ret);
return Ret;
return Ret;
}
GlobalAlias *ilist_traits<GlobalAlias>::createSentinel() {
- GlobalAlias *Ret = new GlobalAlias(Type::Int32Ty, GlobalValue::ExternalLinkage);
+ GlobalAlias *Ret = new GlobalAlias(Type::Int32Ty,
+ GlobalValue::ExternalLinkage);
// This should not be garbage monitored.
LeakDetector::removeGarbageObject(Ret);
return Ret;
delete TypeSymTab;
}
-// Module::dump() - Allow printing from debugger
-void Module::dump() const {
- print(*cerr.stream());
-}
-
/// Target endian information...
Module::Endianness Module::getEndianness() const {
std::string temp = DataLayout;
// 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.
GlobalValue *F = dyn_cast_or_null<GlobalValue>(SymTab.lookup(Name));
if (F == 0) {
// Nope, add it
- Function *New = new Function(Ty, GlobalVariable::ExternalLinkage, Name);
+ 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()) {
- // Rename the function.
- F->setName(SymTab.getUniqueName(F->getName()));
+ if (F->hasLocalLinkage()) {
+ // Clear the function's name.
+ F->setName("");
// Retry, now there won't be a conflict.
- return getOrInsertFunction(Name, Ty);
+ Constant *NewF = getOrInsertFunction(Name, Ty);
+ F->setName(&Name[0], Name.size());
+ return NewF;
}
// If the function exists but has the wrong type, return a bitcast to the
// right type.
- if (F->getType() != PointerType::get(Ty))
- return ConstantExpr::getBitCast(F, PointerType::get(Ty));
+ if (F->getType() != PointerType::getUnqual(Ty))
+ return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
// Otherwise, we just found the existing function or a prototype.
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);
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.
return dyn_cast_or_null<Function>(SymTab.lookup(Name));
}
+Function *Module::getFunction(const char *Name) const {
+ const ValueSymbolTable &SymTab = getValueSymbolTable();
+ return dyn_cast_or_null<Function>(SymTab.lookup(Name, Name+strlen(Name)));
+}
+
//===----------------------------------------------------------------------===//
// Methods for easy access to the global variables in the module.
//
/// 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.
//
return;
}
}
-
projects / oota-llvm.git / blobdiff