ARMSubtarget.cpp revision d3dd50fec00fbbb76edbfaff4d613f1248d21c9e
1//===-- ARMSubtarget.cpp - ARM Subtarget Information ------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the ARM specific subclass of TargetSubtarget. 11// 12//===----------------------------------------------------------------------===// 13 14#include "ARMSubtarget.h" 15#include "ARMGenSubtarget.inc" 16#include "llvm/GlobalValue.h" 17#include "llvm/Target/TargetOptions.h" 18#include "llvm/Support/CommandLine.h" 19using namespace llvm; 20 21static cl::opt<bool> 22ReserveR9("arm-reserve-r9", cl::Hidden, 23 cl::desc("Reserve R9, making it unavailable as GPR")); 24static cl::opt<bool> 25UseNEONFP("arm-use-neon-fp", 26 cl::desc("Use NEON for single-precision FP"), 27 cl::init(false), cl::Hidden); 28 29ARMSubtarget::ARMSubtarget(const std::string &TT, const std::string &FS, 30 bool isT) 31 : ARMArchVersion(V4T) 32 , ARMFPUType(None) 33 , UseNEONForSinglePrecisionFP(UseNEONFP) 34 , IsThumb(isT) 35 , ThumbMode(Thumb1) 36 , PostRAScheduler(false) 37 , IsR9Reserved(ReserveR9) 38 , stackAlignment(4) 39 , CPUString("generic") 40 , TargetType(isELF) // Default to ELF unless otherwise specified. 41 , TargetABI(ARM_ABI_APCS) { 42 // default to soft float ABI 43 if (FloatABIType == FloatABI::Default) 44 FloatABIType = FloatABI::Soft; 45 46 // Determine default and user specified characteristics 47 48 // Parse features string. 49 CPUString = ParseSubtargetFeatures(FS, CPUString); 50 51 // Set the boolean corresponding to the current target triple, or the default 52 // if one cannot be determined, to true. 53 unsigned Len = TT.length(); 54 unsigned Idx = 0; 55 56 if (Len >= 5 && TT.substr(0, 4) == "armv") 57 Idx = 4; 58 else if (Len >= 6 && TT.substr(0, 5) == "thumb") { 59 IsThumb = true; 60 if (Len >= 7 && TT[5] == 'v') 61 Idx = 6; 62 } 63 if (Idx) { 64 unsigned SubVer = TT[Idx]; 65 if (SubVer > '4' && SubVer <= '9') { 66 if (SubVer >= '7') { 67 ARMArchVersion = V7A; 68 } else if (SubVer == '6') { 69 ARMArchVersion = V6; 70 if (Len >= Idx+3 && TT[Idx+1] == 't' && TT[Idx+2] == '2') 71 ARMArchVersion = V6T2; 72 } else if (SubVer == '5') { 73 ARMArchVersion = V5T; 74 if (Len >= Idx+3 && TT[Idx+1] == 't' && TT[Idx+2] == 'e') 75 ARMArchVersion = V5TE; 76 } 77 if (ARMArchVersion >= V6T2) 78 ThumbMode = Thumb2; 79 } 80 } 81 82 // Thumb2 implies at least V6T2. 83 if (ARMArchVersion < V6T2 && ThumbMode >= Thumb2) 84 ARMArchVersion = V6T2; 85 86 if (Len >= 10) { 87 if (TT.find("-darwin") != std::string::npos) 88 // arm-darwin 89 TargetType = isDarwin; 90 } 91 92 if (TT.find("eabi") != std::string::npos) 93 TargetABI = ARM_ABI_AAPCS; 94 95 if (isAAPCS_ABI()) 96 stackAlignment = 8; 97 98 if (isTargetDarwin()) 99 IsR9Reserved = ReserveR9 | (ARMArchVersion < V6); 100 101 if (!isThumb() || hasThumb2()) 102 PostRAScheduler = true; 103 104 // Set CPU specific features. 105 if (CPUString == "cortex-a8") { 106 // On Cortext-a8, it's faster to perform some single-precision FP 107 // operations with NEON instructions. 108 if (UseNEONFP.getPosition() == 0) 109 UseNEONForSinglePrecisionFP = true; 110 } 111} 112 113/// GVIsIndirectSymbol - true if the GV will be accessed via an indirect symbol. 114bool 115ARMSubtarget::GVIsIndirectSymbol(GlobalValue *GV, Reloc::Model RelocM) const { 116 if (RelocM == Reloc::Static) 117 return false; 118 119 // GV with ghost linkage (in JIT lazy compilation mode) do not require an 120 // extra load from stub. 121 bool isDecl = GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode(); 122 123 if (!isTargetDarwin()) { 124 // Extra load is needed for all externally visible. 125 if (GV->hasLocalLinkage() || GV->hasHiddenVisibility()) 126 return false; 127 return true; 128 } else { 129 if (RelocM == Reloc::PIC_) { 130 // If this is a strong reference to a definition, it is definitely not 131 // through a stub. 132 if (!isDecl && !GV->isWeakForLinker()) 133 return false; 134 135 // Unless we have a symbol with hidden visibility, we have to go through a 136 // normal $non_lazy_ptr stub because this symbol might be resolved late. 137 if (!GV->hasHiddenVisibility()) // Non-hidden $non_lazy_ptr reference. 138 return true; 139 140 // If symbol visibility is hidden, we have a stub for common symbol 141 // references and external declarations. 142 if (isDecl || GV->hasCommonLinkage()) 143 // Hidden $non_lazy_ptr reference. 144 return true; 145 146 return false; 147 } else { 148 // If this is a strong reference to a definition, it is definitely not 149 // through a stub. 150 if (!isDecl && !GV->isWeakForLinker()) 151 return false; 152 153 // Unless we have a symbol with hidden visibility, we have to go through a 154 // normal $non_lazy_ptr stub because this symbol might be resolved late. 155 if (!GV->hasHiddenVisibility()) // Non-hidden $non_lazy_ptr reference. 156 return true; 157 } 158 } 159 160 return false; 161} 162