Do not use make<> to allocate TargetInfo. NFC.

llvm-svn: 305577

lld/ELF/Arch/AArch64.cpp

@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
@@ -371,4 +370,7 @@ void AArch64::relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const {
   llvm_unreachable("invalid relocation for TLS IE to LE relaxation");
 }
 
-TargetInfo *elf::createAArch64TargetInfo() { return make<AArch64>(); }
+TargetInfo *elf::getAArch64TargetInfo() {
+  static AArch64 Target;
+  return &Target;
+}

lld/ELF/Arch/AMDGPU.cpp

@@ -9,7 +9,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "llvm/Object/ELF.h"
@@ -79,4 +78,7 @@ RelExpr AMDGPU::getRelExpr(uint32_t Type, const SymbolBody &S,
   }
 }
 
-TargetInfo *elf::createAMDGPUTargetInfo() { return make<AMDGPU>(); }
+TargetInfo *elf::getAMDGPUTargetInfo() {
+  static AMDGPU Target;
+  return &Target;
+}

lld/ELF/Arch/ARM.cpp

@@ -9,7 +9,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
@@ -429,4 +428,7 @@ int64_t ARM::getImplicitAddend(const uint8_t *Buf, uint32_t Type) const {
   }
 }
 
-TargetInfo *elf::createARMTargetInfo() { return make<ARM>(); }
+TargetInfo *elf::getARMTargetInfo() {
+  static ARM Target;
+  return &Target;
+}

lld/ELF/Arch/AVR.cpp

@@ -28,7 +28,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "llvm/Object/ELF.h"
@@ -75,4 +74,7 @@ void AVR::relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const {
   }
 }
 
-TargetInfo *elf::createAVRTargetInfo() { return make<AVR>(); }
+TargetInfo *elf::getAVRTargetInfo() {
+  static AVR Target;
+  return &Target;
+}

lld/ELF/Arch/Mips.cpp

@@ -9,7 +9,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "OutputSections.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
@@ -412,11 +411,12 @@ bool MIPS<ELFT>::usesOnlyLowPageBits(uint32_t Type) const {
   return Type == R_MIPS_LO16 || Type == R_MIPS_GOT_OFST;
 }
 
-template <class ELFT> TargetInfo *elf::createMipsTargetInfo() {
-  return make<MIPS<ELFT>>();
+template <class ELFT> TargetInfo *elf::getMipsTargetInfo() {
+  static MIPS<ELFT> Target;
+  return &Target;
 }
 
-template TargetInfo *elf::createMipsTargetInfo<ELF32LE>();
-template TargetInfo *elf::createMipsTargetInfo<ELF32BE>();
-template TargetInfo *elf::createMipsTargetInfo<ELF64LE>();
-template TargetInfo *elf::createMipsTargetInfo<ELF64BE>();
+template TargetInfo *elf::getMipsTargetInfo<ELF32LE>();
+template TargetInfo *elf::getMipsTargetInfo<ELF32BE>();
+template TargetInfo *elf::getMipsTargetInfo<ELF64LE>();
+template TargetInfo *elf::getMipsTargetInfo<ELF64BE>();

lld/ELF/Arch/PPC.cpp

@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "llvm/Support/Endian.h"
@@ -60,4 +59,7 @@ RelExpr PPC::getRelExpr(uint32_t Type, const SymbolBody &S,
   }
 }
 
-TargetInfo *elf::createPPCTargetInfo() { return make<PPC>(); }
+TargetInfo *elf::getPPCTargetInfo() {
+  static PPC Target;
+  return &Target;
+}

lld/ELF/Arch/PPC64.cpp

@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
@@ -212,4 +211,7 @@ void PPC64::relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const {
   }
 }
 
-TargetInfo *elf::createPPC64TargetInfo() { return make<PPC64>(); }
+TargetInfo *elf::getPPC64TargetInfo() {
+  static PPC64 Target;
+  return &Target;
+}

lld/ELF/Arch/X86.cpp

@@ -9,7 +9,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
@@ -360,4 +359,7 @@ void X86::relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const {
   memcpy(Loc - 2, Inst, sizeof(Inst));
 }
 
-TargetInfo *elf::createX86TargetInfo() { return make<X86>(); }
+TargetInfo *elf::getX86TargetInfo() {
+  static X86 Target;
+  return &Target;
+}

lld/ELF/Arch/X86_64.cpp

@@ -9,7 +9,6 @@
 
 #include "Error.h"
 #include "InputFiles.h"
-#include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
@@ -464,5 +463,12 @@ void X86_64<ELFT>::relaxGot(uint8_t *Loc, uint64_t Val) const {
   write32le(Loc - 1, Val + 1);
 }
 
-TargetInfo *elf::createX32TargetInfo() { return make<X86_64<ELF32LE>>(); }
-TargetInfo *elf::createX86_64TargetInfo() { return make<X86_64<ELF64LE>>(); }
+TargetInfo *elf::getX32TargetInfo() {
+  static X86_64<ELF32LE> Target;
+  return &Target;
+}
+
+TargetInfo *elf::getX86_64TargetInfo() {
+  static X86_64<ELF64LE> Target;
+  return &Target;
+}

lld/ELF/Driver.cpp

@@ -912,7 +912,7 @@ getDefsym(opt::InputArgList &Args) {
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   elf::Symtab<ELFT>::X = &Symtab;
-  Target = createTarget();
+  Target = getTarget();
 
   Config->MaxPageSize = getMaxPageSize(Args);
   Config->ImageBase = getImageBase(Args);

lld/ELF/Target.cpp

@@ -47,40 +47,40 @@ std::string lld::toString(uint32_t Type) {
   return S;
 }
 
-TargetInfo *elf::createTarget() {
+TargetInfo *elf::getTarget() {
   switch (Config->EMachine) {
   case EM_386:
   case EM_IAMCU:
-    return createX86TargetInfo();
+    return getX86TargetInfo();
   case EM_AARCH64:
-    return createAArch64TargetInfo();
+    return getAArch64TargetInfo();
   case EM_AMDGPU:
-    return createAMDGPUTargetInfo();
+    return getAMDGPUTargetInfo();
   case EM_ARM:
-    return createARMTargetInfo();
+    return getARMTargetInfo();
   case EM_AVR:
-    return createAVRTargetInfo();
+    return getAVRTargetInfo();
   case EM_MIPS:
     switch (Config->EKind) {
     case ELF32LEKind:
-      return createMipsTargetInfo<ELF32LE>();
+      return getMipsTargetInfo<ELF32LE>();
     case ELF32BEKind:
-      return createMipsTargetInfo<ELF32BE>();
+      return getMipsTargetInfo<ELF32BE>();
     case ELF64LEKind:
-      return createMipsTargetInfo<ELF64LE>();
+      return getMipsTargetInfo<ELF64LE>();
     case ELF64BEKind:
-      return createMipsTargetInfo<ELF64BE>();
+      return getMipsTargetInfo<ELF64BE>();
     default:
       fatal("unsupported MIPS target");
     }
   case EM_PPC:
-    return createPPCTargetInfo();
+    return getPPCTargetInfo();
   case EM_PPC64:
-    return createPPC64TargetInfo();
+    return getPPC64TargetInfo();
   case EM_X86_64:
     if (Config->EKind == ELF32LEKind)
-      return createX32TargetInfo();
-    return createX86_64TargetInfo();
+      return getX32TargetInfo();
+    return getX86_64TargetInfo();
   }
   fatal("unknown target machine");
 }

lld/ELF/Target.h

@@ -102,16 +102,16 @@ public:
   virtual void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
 };
 
-TargetInfo *createAArch64TargetInfo();
-TargetInfo *createAMDGPUTargetInfo();
-TargetInfo *createARMTargetInfo();
-TargetInfo *createAVRTargetInfo();
-TargetInfo *createPPC64TargetInfo();
-TargetInfo *createPPCTargetInfo();
-TargetInfo *createX32TargetInfo();
-TargetInfo *createX86TargetInfo();
-TargetInfo *createX86_64TargetInfo();
-template <class ELFT> TargetInfo *createMipsTargetInfo();
+TargetInfo *getAArch64TargetInfo();
+TargetInfo *getAMDGPUTargetInfo();
+TargetInfo *getARMTargetInfo();
+TargetInfo *getAVRTargetInfo();
+TargetInfo *getPPC64TargetInfo();
+TargetInfo *getPPCTargetInfo();
+TargetInfo *getX32TargetInfo();
+TargetInfo *getX86TargetInfo();
+TargetInfo *getX86_64TargetInfo();
+template <class ELFT> TargetInfo *getMipsTargetInfo();
 
 std::string getErrorLocation(const uint8_t *Loc);
 
@@ -119,7 +119,7 @@ uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t Expr);
 
 extern TargetInfo *Target;
-TargetInfo *createTarget();
+TargetInfo *getTarget();
 
 template <unsigned N>
 static void checkInt(uint8_t *Loc, int64_t V, uint32_t Type) {