#include "llvm/Module.h"
#include "llvm/DerivedTypes.h"
#include "llvm/IntrinsicInst.h"
+#include "llvm/LLVMContext.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/Support/LeakDetector.h"
#include "llvm/Support/ManagedStatic.h"
// Argument Implementation
//===----------------------------------------------------------------------===//
-Argument::Argument(const Type *Ty, const std::string &Name, Function *Par)
+Argument::Argument(const Type *Ty, const Twine &Name, Function *Par)
: Value(Ty, Value::ArgumentVal) {
Parent = 0;
// Helper Methods in Function
//===----------------------------------------------------------------------===//
+LLVMContext &Function::getContext() const {
+ return getType()->getContext();
+}
+
const FunctionType *Function::getFunctionType() const {
return cast<FunctionType>(getType()->getElementType());
}
//===----------------------------------------------------------------------===//
Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
- const std::string &name, Module *ParentModule)
+ const Twine &name, Module *ParentModule)
: GlobalValue(PointerType::getUnqual(Ty),
Value::FunctionVal, 0, 0, Linkage, name) {
assert(FunctionType::isValidReturnType(getReturnType()) &&
// use GC.
static DenseMap<const Function*,PooledStringPtr> *GCNames;
static StringPool *GCNamePool;
-static ManagedStatic<sys::RWMutex> GCLock;
+static ManagedStatic<sys::SmartRWMutex<true> > GCLock;
bool Function::hasGC() const {
- if (llvm_is_multithreaded()) {
- sys::ScopedReader Reader(&*GCLock);
- return GCNames && GCNames->count(this);
- } else
- return GCNames && GCNames->count(this);
+ sys::SmartScopedReader<true> Reader(*GCLock);
+ return GCNames && GCNames->count(this);
}
const char *Function::getGC() const {
assert(hasGC() && "Function has no collector");
- if (llvm_is_multithreaded()) {
- sys::ScopedReader Reader(&*GCLock);
- return *(*GCNames)[this];
- } else
- return *(*GCNames)[this];
+ sys::SmartScopedReader<true> Reader(*GCLock);
+ return *(*GCNames)[this];
}
void Function::setGC(const char *Str) {
- if (llvm_is_multithreaded()) GCLock->writer_acquire();
+ sys::SmartScopedWriter<true> Writer(*GCLock);
if (!GCNamePool)
GCNamePool = new StringPool();
if (!GCNames)
GCNames = new DenseMap<const Function*,PooledStringPtr>();
(*GCNames)[this] = GCNamePool->intern(Str);
- if (llvm_is_multithreaded()) GCLock->writer_release();
}
void Function::clearGC() {
- if (llvm_is_multithreaded()) GCLock->writer_acquire();
+ sys::SmartScopedWriter<true> Writer(*GCLock);
if (GCNames) {
GCNames->erase(this);
if (GCNames->empty()) {
}
}
}
- if (llvm_is_multithreaded()) GCLock->writer_release();
}
/// copyAttributesFrom - copy all additional attributes (those not needed to
return Result;
}
-const FunctionType *Intrinsic::getType(ID id, const Type **Tys,
+const FunctionType *Intrinsic::getType(LLVMContext &Context,
+ ID id, const Type **Tys,
unsigned numTys) {
const Type *ResultTy = NULL;
std::vector<const Type*> ArgTys;
#include "llvm/Intrinsics.gen"
#undef GET_INTRINSIC_GENERATOR
- return FunctionType::get(ResultTy, ArgTys, IsVarArg);
+ return Context.getFunctionType(ResultTy, ArgTys, IsVarArg);
}
bool Intrinsic::isOverloaded(ID id) {
// because intrinsics must be a specific type.
return
cast<Function>(M->getOrInsertFunction(getName(id, Tys, numTys),
- getType(id, Tys, numTys)));
+ getType(M->getContext(),
+ id, Tys, numTys)));
}
// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.