Simplify.

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

diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index 96c679240510b846aeb4d302cd7e2f9fe343b116..cdf2dd07fa6840a1446b0b3b0773ce2fff031dc3 100644 (file)
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -14,11 +14,13 @@
 #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"
 #include "llvm/Support/StringPool.h"
 #include "llvm/System/RWMutex.h"
+#include "llvm/System/Threading.h"
 #include "SymbolTableListTraitsImpl.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
@@ -34,7 +36,7 @@ template class SymbolTableListTraits<BasicBlock, Function>;
 // 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;
 
@@ -113,6 +115,10 @@ void Argument::removeAttr(Attributes attr) {
 // Helper Methods in Function
 //===----------------------------------------------------------------------===//
 
+LLVMContext &Function::getContext() const {
+  return getType()->getContext();
+}
+
 const FunctionType *Function::getFunctionType() const {
   return cast<FunctionType>(getType()->getElementType());
 }
@@ -138,7 +144,7 @@ void Function::eraseFromParent() {
 //===----------------------------------------------------------------------===//
 
 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()) &&
@@ -230,42 +236,43 @@ void Function::removeAttribute(unsigned i, Attributes attr) {
 // allocating an additional word in Function for programs which do not use GC
 // (i.e., most programs) at the cost of increased overhead for clients which do
 // use GC.
-static ManagedStatic<DenseMap<const Function*,PooledStringPtr> > GCNames;
-static ManagedStatic<StringPool> GCNamePool;
-static ManagedStatic<sys::RWMutex> GCLock;
+static DenseMap<const Function*,PooledStringPtr> *GCNames;
+static StringPool *GCNamePool;
+static ManagedStatic<sys::SmartRWMutex<true> > GCLock;
 
 bool Function::hasGC() const {
-  if (llvm_is_multithreaded()) {
-    sys::ScopedReader Reader(&*GCLock);
-    return GCNames->count(this);
-  } else 
-    return 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()) {
-    sys::ScopedWriter Writer(&*GCLock);
-    (*GCNames)[this] = GCNamePool->intern(Str);
-  } else
-    (*GCNames)[this] = GCNamePool->intern(Str); 
+  sys::SmartScopedWriter<true> Writer(*GCLock);
+  if (!GCNamePool)
+    GCNamePool = new StringPool();
+  if (!GCNames)
+    GCNames = new DenseMap<const Function*,PooledStringPtr>();
+  (*GCNames)[this] = GCNamePool->intern(Str);
 }
 
 void Function::clearGC() {
-  if (llvm_is_multithreaded()) {
-    sys::ScopedWriter Writer(&*GCLock);
-    GCNames->erase(this);
-  } else
+  sys::SmartScopedWriter<true> Writer(*GCLock);
+  if (GCNames) {
     GCNames->erase(this);
+    if (GCNames->empty()) {
+      delete GCNames;
+      GCNames = 0;
+      if (GCNamePool->empty()) {
+        delete GCNamePool;
+        GCNamePool = 0;
+      }
+    }
+  }
 }
 
 /// copyAttributesFrom - copy all additional attributes (those not needed to
@@ -328,7 +335,8 @@ std::string Intrinsic::getName(ID id, const Type **Tys, unsigned numTys) {
   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;
@@ -338,7 +346,7 @@ const FunctionType *Intrinsic::getType(ID id, const Type **Tys,
 #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) {
@@ -362,7 +370,8 @@ Function *Intrinsic::getDeclaration(Module *M, ID id, const Type **Tys,
   // 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.