X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=lib%2FTarget%2FX86%2FX86Subtarget.cpp;h=610bf1da432b2b16053368326fad2141b6783ba1;hb=51cc3c13eac78da242f0518fc42580e48dd5304f;hp=be5c64d6d3bc7ab6741577bbf03d8fc6ba62058c;hpb=5032e5a61381437174e035de2a7dd728978f7bd5;p=oota-llvm.git diff --git a/lib/Target/X86/X86Subtarget.cpp b/lib/Target/X86/X86Subtarget.cpp index be5c64d6d3b..610bf1da432 100644 --- a/lib/Target/X86/X86Subtarget.cpp +++ b/lib/Target/X86/X86Subtarget.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Nate Begeman 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. // //===----------------------------------------------------------------------===// // @@ -26,6 +26,10 @@ AsmWriterFlavor("x86-asm-syntax", cl::init(X86Subtarget::Unset), clEnumValN(X86Subtarget::Intel, "intel", " Emit Intel-style assembly"), clEnumValEnd)); +cl::opt +StackAlignment("stack-alignment", cl::init(0), + cl::desc("Override default stack alignment")); + /// True if accessing the GV requires an extra load. For Windows, dllimported /// symbols are indirect, loading the value at address GV rather then the @@ -35,22 +39,38 @@ bool X86Subtarget::GVRequiresExtraLoad(const GlobalValue* GV, const TargetMachine& TM, bool isDirectCall) const { - if (TM.getRelocationModel() != Reloc::Static) + // FIXME: PIC + if (TM.getRelocationModel() != Reloc::Static) { if (isTargetDarwin()) { return (!isDirectCall && (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() || - (GV->isExternal() && !GV->hasNotBeenReadFromBytecode()))); - } else if (isPICStyleGOT()) { + (GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode()))); + } else if (isTargetELF()) { // Extra load is needed for all non-statics. return (!isDirectCall && - (GV->isExternal() || !GV->hasInternalLinkage())); + (GV->isDeclaration() || !GV->hasInternalLinkage())); } else if (isTargetCygMing() || isTargetWindows()) { return (GV->hasDLLImportLinkage()); } + } return false; } +/// This function returns the name of a function which has an interface +/// like the non-standard bzero function, if such a function exists on +/// the current subtarget and it is considered prefereable over +/// memset with zero passed as the second argument. Otherwise it +/// returns null. +const char *X86Subtarget::getBZeroEntry() const { + + // Darwin 10 has a __bzero entry point for this purpose. + if (getDarwinVers() >= 10) + return "__bzero"; + + return 0; +} + /// GetCpuIDAndInfo - Execute the specified cpuid and return the 4 values in the /// specified arguments. If we can't run cpuid on the host, return true. bool X86::GetCpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX, @@ -105,16 +125,19 @@ void X86Subtarget::AutoDetectSubtargetFeatures() { if (X86::GetCpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1)) return; - - // FIXME: support for AMD family of processors. - if (memcmp(text.c, "GenuineIntel", 12) == 0) { - X86::GetCpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX); - if ((EDX >> 23) & 0x1) X86SSELevel = MMX; - if ((EDX >> 25) & 0x1) X86SSELevel = SSE1; - if ((EDX >> 26) & 0x1) X86SSELevel = SSE2; - if (ECX & 0x1) X86SSELevel = SSE3; + X86::GetCpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX); + + if ((EDX >> 23) & 0x1) X86SSELevel = MMX; + if ((EDX >> 25) & 0x1) X86SSELevel = SSE1; + if ((EDX >> 26) & 0x1) X86SSELevel = SSE2; + if (ECX & 0x1) X86SSELevel = SSE3; + if ((ECX >> 9) & 0x1) X86SSELevel = SSSE3; + if ((ECX >> 19) & 0x1) X86SSELevel = SSE41; + if ((ECX >> 20) & 0x1) X86SSELevel = SSE42; + if (memcmp(text.c, "GenuineIntel", 12) == 0 || + memcmp(text.c, "AuthenticAMD", 12) == 0) { X86::GetCpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX); HasX86_64 = (EDX >> 29) & 0x1; } @@ -202,10 +225,10 @@ static const char *GetCurrentX86CPU() { } case 15: switch (Model) { + case 1: return "opteron"; case 5: return "athlon-fx"; // also opteron default: return "athlon64"; } - default: return "generic"; } @@ -218,10 +241,12 @@ X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit) : AsmFlavor(AsmWriterFlavor) , PICStyle(PICStyle::None) , X86SSELevel(NoMMXSSE) + , X863DNowLevel(NoThreeDNow) , HasX86_64(false) + , DarwinVers(0) , stackAlignment(8) // FIXME: this is a known good value for Yonah. How about others? - , MinRepStrSizeThreshold(128) + , MaxInlineSizeThreshold(128) , Is64Bit(is64Bit) , TargetType(isELF) { // Default to ELF unless otherwise specified. @@ -230,12 +255,6 @@ X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit) // If feature string is not empty, parse features string. std::string CPU = GetCurrentX86CPU(); ParseSubtargetFeatures(FS, CPU); - - if (Is64Bit && !HasX86_64) - cerr << "Warning: Generation of 64-bit code for a 32-bit processor " - << "requested.\n"; - if (Is64Bit && X86SSELevel < SSE2) - cerr << "Warning: 64-bit processors all have at least SSE2.\n"; } else { // Otherwise, use CPUID to auto-detect feature set. AutoDetectSubtargetFeatures(); @@ -253,22 +272,38 @@ X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit) // if one cannot be determined, to true. const std::string& TT = M.getTargetTriple(); if (TT.length() > 5) { - if (TT.find("cygwin") != std::string::npos) + size_t Pos; + if ((Pos = TT.find("-darwin")) != std::string::npos) { + TargetType = isDarwin; + + // Compute the darwin version number. + if (isdigit(TT[Pos+7])) + DarwinVers = atoi(&TT[Pos+7]); + else + DarwinVers = 8; // Minimum supported darwin is Tiger. + } else if (TT.find("cygwin") != std::string::npos) { TargetType = isCygwin; - else if (TT.find("mingw") != std::string::npos) + } else if (TT.find("mingw") != std::string::npos) { TargetType = isMingw; - else if (TT.find("darwin") != std::string::npos) - TargetType = isDarwin; - else if (TT.find("win32") != std::string::npos) + } else if (TT.find("win32") != std::string::npos) { TargetType = isWindows; + } else if (TT.find("windows") != std::string::npos) { + TargetType = isWindows; + } } else if (TT.empty()) { #if defined(__CYGWIN__) TargetType = isCygwin; -#elif defined(__MINGW32__) +#elif defined(__MINGW32__) || defined(__MINGW64__) TargetType = isMingw; #elif defined(__APPLE__) TargetType = isDarwin; -#elif defined(_WIN32) +#if __APPLE_CC__ > 5400 + DarwinVers = 9; // GCC 5400+ is Leopard. +#else + DarwinVers = 8; // Minimum supported darwin is Tiger. +#endif + +#elif defined(_WIN32) || defined(_WIN64) TargetType = isWindows; #endif } @@ -276,16 +311,17 @@ X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit) // If the asm syntax hasn't been overridden on the command line, use whatever // the target wants. if (AsmFlavor == X86Subtarget::Unset) { - if (TargetType == isWindows) { - AsmFlavor = X86Subtarget::Intel; - } else { - AsmFlavor = X86Subtarget::ATT; - } + AsmFlavor = (TargetType == isWindows) + ? X86Subtarget::Intel : X86Subtarget::ATT; } if (TargetType == isDarwin || TargetType == isCygwin || TargetType == isMingw || + TargetType == isWindows || (TargetType == isELF && Is64Bit)) stackAlignment = 16; + + if (StackAlignment) + stackAlignment = StackAlignment; }