[llvm-commits] CVS: llvm/lib/Target/X86/X86Subtarget.cpp X86Subtarget.h X86ISelPattern.cpp X86TargetMachine.cpp X86TargetMachine.h
Nate Begeman
natebegeman at mac.com
Mon Jul 11 18:42:05 PDT 2005
Changes in directory llvm/lib/Target/X86:
X86Subtarget.cpp added (r1.1)
X86Subtarget.h added (r1.1)
X86ISelPattern.cpp updated: 1.149 -> 1.150
X86TargetMachine.cpp updated: 1.82 -> 1.83
X86TargetMachine.h updated: 1.28 -> 1.29
---
Log message:
Implement Subtarget support
Implement the X86 Subtarget.
This consolidates the checks for target triple, and setting options based
on target triple into one place. This allows us to convert the asm printer
and isel over from being littered with "forDarwin", "forCygwin", etc. into
just having the appropriate flags for each subtarget feature controlling
the code for that feature.
This patch also implements indirect external and weak references in the
X86 pattern isel, for darwin. Next up is to convert over the asm printers
to use this new interface.
---
Diffs of the changes: (+148 -4)
X86ISelPattern.cpp | 31 ++++++++++++++++++++++++--
X86Subtarget.cpp | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++
X86Subtarget.h | 55 +++++++++++++++++++++++++++++++++++++++++++++++
X86TargetMachine.cpp | 4 ++-
X86TargetMachine.h | 3 ++
5 files changed, 148 insertions(+), 4 deletions(-)
Index: llvm/lib/Target/X86/X86Subtarget.cpp
diff -c /dev/null llvm/lib/Target/X86/X86Subtarget.cpp:1.1
*** /dev/null Mon Jul 11 20:42:04 2005
--- llvm/lib/Target/X86/X86Subtarget.cpp Mon Jul 11 20:41:54 2005
***************
*** 0 ****
--- 1,59 ----
+ //===- X86Subtarget.cpp - X86 Instruction Information -----------*- C++ -*-===//
+ //
+ // 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 implements the X86 specific subclass of TargetSubtarget.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #include "X86Subtarget.h"
+ #include "llvm/Module.h"
+ using namespace llvm;
+
+ X86Subtarget::X86Subtarget(const Module &M)
+ : TargetSubtarget(M), stackAlignment(8),
+ indirectExternAndWeakGlobals(false), asmDarwinLinkerStubs(false),
+ asmLeadingUnderscore(false), asmAlignmentIsInBytes(false),
+ asmPrintDotLocalConstants(false), asmPrintDotLCommConstants(false),
+ asmPrintConstantAlignment(false) {
+ // Declare a boolean for each platform
+ bool forCygwin = false;
+ bool forDarwin = false;
+ bool forWindows = false;
+
+ // Set the boolean corresponding to the current target triple, or the default
+ // if one cannot be determined, to true.
+ const std::string& TT = M.getTargetTriple();
+ if (TT.length() > 5) {
+ forCygwin = TT.find("cygwin") != std::string::npos ||
+ TT.find("mingw") != std::string::npos;
+ forDarwin = TT.find("darwin") != std::string::npos;
+ forWindows = TT.find("win32") != std::string::npos;
+ } else if (TT.empty()) {
+ #if defined(__CYGWIN__) || defined(__MINGW32__)
+ forCygwin = true;
+ #elif defined(__APPLE__)
+ forDarwin = true;
+ #elif defined(_WIN32)
+ forWindws = true;
+ #endif
+ }
+
+ if (forCygwin) {
+ asmLeadingUnderscore = true;
+ }
+ if (forDarwin) {
+ stackAlignment = 16;
+ indirectExternAndWeakGlobals = true;
+ asmDarwinLinkerStubs = true;
+ asmLeadingUnderscore = true;
+ asmPrintDotLCommConstants = true;
+ }
+ if (forWindows) {
+ }
+ }
Index: llvm/lib/Target/X86/X86Subtarget.h
diff -c /dev/null llvm/lib/Target/X86/X86Subtarget.h:1.1
*** /dev/null Mon Jul 11 20:42:05 2005
--- llvm/lib/Target/X86/X86Subtarget.h Mon Jul 11 20:41:54 2005
***************
*** 0 ****
--- 1,55 ----
+ //=====-- X86Subtarget.h - Define TargetMachine for the X86 ---*- C++ -*--====//
+ //
+ // 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 declares the X86 specific subclass of TargetSubtarget.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #ifndef X86SUBTARGET_H
+ #define X86SUBTARGET_H
+
+ #include "llvm/Target/TargetSubtarget.h"
+
+ namespace llvm {
+ class Module;
+
+ class X86Subtarget : public TargetSubtarget {
+ protected:
+ /// Used by the target machine to set up the target frame info
+ unsigned stackAlignment;
+
+ /// Used by instruction selector
+ bool indirectExternAndWeakGlobals;
+
+ /// Used by the asm printer
+ bool asmDarwinLinkerStubs;
+ bool asmLeadingUnderscore;
+ bool asmAlignmentIsInBytes;
+ bool asmPrintDotLocalConstants;
+ bool asmPrintDotLCommConstants;
+ bool asmPrintConstantAlignment;
+ public:
+ /// This constructor initializes the data members to match that
+ /// of the specified module.
+ ///
+ X86Subtarget(const Module &M);
+
+ /// Returns the preferred stack alignment for the current target triple, or
+ /// the default if no target triple is set.
+ unsigned getStackAlignment() const { return stackAlignment; }
+
+ /// Returns true if the instruction selector should treat global values
+ /// referencing external or weak symbols as indirect rather than direct
+ /// references.
+ bool getIndirectExternAndWeakGlobals() const {
+ return indirectExternAndWeakGlobals; }
+ };
+ } // End llvm namespace
+
+ #endif
Index: llvm/lib/Target/X86/X86ISelPattern.cpp
diff -u llvm/lib/Target/X86/X86ISelPattern.cpp:1.149 llvm/lib/Target/X86/X86ISelPattern.cpp:1.150
--- llvm/lib/Target/X86/X86ISelPattern.cpp:1.149 Sat Jul 9 20:56:13 2005
+++ llvm/lib/Target/X86/X86ISelPattern.cpp Mon Jul 11 20:41:54 2005
@@ -14,6 +14,7 @@
#include "X86.h"
#include "X86InstrBuilder.h"
#include "X86RegisterInfo.h"
+#include "X86Subtarget.h"
#include "llvm/CallingConv.h"
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
@@ -26,6 +27,7 @@
#include "llvm/CodeGen/SSARegMap.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
+#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/MathExtras.h"
@@ -996,8 +998,13 @@
/// TheDAG - The DAG being selected during Select* operations.
SelectionDAG *TheDAG;
+
+ /// Subtarget - Keep a pointer to the X86Subtarget around so that we can
+ /// make the right decision when generating code for different targets.
+ const X86Subtarget *Subtarget;
public:
ISel(TargetMachine &TM) : SelectionDAGISel(X86Lowering), X86Lowering(TM) {
+ Subtarget = TM.getSubtarget<const X86Subtarget>();
}
virtual const char *getPassName() const {
@@ -1314,8 +1321,18 @@
break;
case ISD::GlobalAddress:
if (AM.GV == 0) {
- AM.GV = cast<GlobalAddressSDNode>(N)->getGlobal();
- return false;
+ GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal();
+ // For Darwin, external and weak symbols are indirect, so we want to load
+ // the value at address GV, not the value of GV itself. This means that
+ // the GlobalAddress must be in the base or index register of the address,
+ // not the GV offset field.
+ if (Subtarget->getIndirectExternAndWeakGlobals() &&
+ (GV->hasWeakLinkage() || GV->isExternal())) {
+ break;
+ } else {
+ AM.GV = GV;
+ return false;
+ }
}
break;
case ISD::Constant:
@@ -2236,7 +2253,15 @@
return Result;
case ISD::GlobalAddress: {
GlobalValue *GV = cast<GlobalAddressSDNode>(N)->getGlobal();
- BuildMI(BB, X86::MOV32ri, 1, Result).addGlobalAddress(GV);
+ // For Darwin, external and weak symbols are indirect, so we want to load
+ // the value at address GV, not the value of GV itself.
+ if (Subtarget->getIndirectExternAndWeakGlobals() &&
+ (GV->hasWeakLinkage() || GV->isExternal())) {
+ BuildMI(BB, X86::MOV32rm, 4, Result).addReg(0).addZImm(1).addReg(0)
+ .addGlobalAddress(GV, false, 0);
+ } else {
+ BuildMI(BB, X86::MOV32ri, 1, Result).addGlobalAddress(GV);
+ }
return Result;
}
case ISD::ExternalSymbol: {
Index: llvm/lib/Target/X86/X86TargetMachine.cpp
diff -u llvm/lib/Target/X86/X86TargetMachine.cpp:1.82 llvm/lib/Target/X86/X86TargetMachine.cpp:1.83
--- llvm/lib/Target/X86/X86TargetMachine.cpp:1.82 Mon Jul 11 00:17:48 2005
+++ llvm/lib/Target/X86/X86TargetMachine.cpp Mon Jul 11 20:41:54 2005
@@ -92,7 +92,9 @@
///
X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *IL)
: TargetMachine("X86", IL, true, 4, 4, 4, 4, 4),
- FrameInfo(TargetFrameInfo::StackGrowsDown, 8, -4),
+ Subtarget(M),
+ FrameInfo(TargetFrameInfo::StackGrowsDown,
+ Subtarget.getStackAlignment(), -4),
JITInfo(*this) {
// Scalar SSE FP requires at least SSE2
X86ScalarSSE &= X86Vector >= SSE2;
Index: llvm/lib/Target/X86/X86TargetMachine.h
diff -u llvm/lib/Target/X86/X86TargetMachine.h:1.28 llvm/lib/Target/X86/X86TargetMachine.h:1.29
--- llvm/lib/Target/X86/X86TargetMachine.h:1.28 Fri Jun 24 21:48:37 2005
+++ llvm/lib/Target/X86/X86TargetMachine.h Mon Jul 11 20:41:54 2005
@@ -19,12 +19,14 @@
#include "llvm/PassManager.h"
#include "X86InstrInfo.h"
#include "X86JITInfo.h"
+#include "X86Subtarget.h"
namespace llvm {
class IntrinsicLowering;
class X86TargetMachine : public TargetMachine {
X86InstrInfo InstrInfo;
+ X86Subtarget Subtarget;
TargetFrameInfo FrameInfo;
X86JITInfo JITInfo;
public:
@@ -33,6 +35,7 @@
virtual const X86InstrInfo *getInstrInfo() const { return &InstrInfo; }
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }
virtual TargetJITInfo *getJITInfo() { return &JITInfo; }
+ virtual const TargetSubtarget *getSubtargetImpl() const{ return &Subtarget; }
virtual const MRegisterInfo *getRegisterInfo() const {
return &InstrInfo.getRegisterInfo();
}
More information about the llvm-commits
mailing list