#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/Mangler.h"
-#include "llvm/Support/raw_ostream.h"
using namespace llvm;
namespace {
class VISIBILITY_HIDDEN SystemZAsmPrinter : public AsmPrinter {
public:
- SystemZAsmPrinter(raw_ostream &O, SystemZTargetMachine &TM,
- const TargetAsmInfo *TAI,
- CodeGenOpt::Level OL, bool V)
- : AsmPrinter(O, TM, TAI, OL, V) {}
+ SystemZAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
+ const TargetAsmInfo *TAI, bool V)
+ : AsmPrinter(O, TM, TAI, V) {}
virtual const char *getPassName() const {
return "SystemZ Assembly Printer";
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
-FunctionPass *llvm::createSystemZCodePrinterPass(raw_ostream &o,
- SystemZTargetMachine &tm,
- CodeGenOpt::Level OptLevel,
- bool verbose) {
- return new SystemZAsmPrinter(o, tm, tm.getTargetAsmInfo(), OptLevel, verbose);
+FunctionPass *llvm::createSystemZCodePrinterPass(formatted_raw_ostream &o,
+ TargetMachine &tm,
+ bool verbose) {
+ return new SystemZAsmPrinter(o, tm, tm.getTargetAsmInfo(), verbose);
}
bool SystemZAsmPrinter::doInitialization(Module &M) {
}
void SystemZAsmPrinter::emitFunctionHeader(const MachineFunction &MF) {
+ unsigned FnAlign = MF.getAlignment();
const Function *F = MF.getFunction();
SwitchToSection(TAI->SectionForGlobal(F));
- unsigned FnAlign = 4;
- if (F->hasFnAttr(Attribute::OptimizeForSize))
- FnAlign = 1;
-
EmitAlignment(FnAlign, F);
switch (F->getLinkage()) {
return;
case MachineOperand::MO_GlobalAddress: {
const GlobalValue *GV = MO.getGlobal();
- std::string Name = Mang->getValueName(GV);
+ std::string Name = Mang->getMangledName(GV);
O << Name;
break;
case MachineOperand::MO_GlobalAddress: {
const GlobalValue *GV = MO.getGlobal();
- std::string Name = Mang->getValueName(GV);
+ std::string Name = Mang->getMangledName(GV);
O << Name;
break;
/// PrintUnmangledNameSafely - Print out the printable characters in the name.
/// Don't print things like \\n or \\0.
-static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
+static void PrintUnmangledNameSafely(const Value *V, formatted_raw_ostream &OS) {
for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
Name != E; ++Name)
if (isprint(*Name))
if (EmitSpecialLLVMGlobal(GVar))
return;
- std::string name = Mang->getValueName(GVar);
+ std::string name = Mang->getMangledName(GVar);
Constant *C = GVar->getInitializer();
- const Type *Type = C->getType();
- unsigned Size = TD->getTypeAllocSize(Type);
+ unsigned Size = TD->getTypeAllocSize(C->getType());
unsigned Align = std::max(1U, TD->getPreferredAlignmentLog(GVar));
printVisibility(name, GVar->getVisibility());
EmitGlobalConstant(C);
}
+
+// Force static initialization.
+extern "C" void LLVMInitializeSystemZAsmPrinter() {
+ extern Target TheSystemZTarget;
+ TargetRegistry::RegisterAsmPrinter(TheSystemZTarget,
+ createSystemZCodePrinterPass);
+}
SystemZGenInstrInfo.inc SystemZGenAsmWriter.inc \
SystemZGenDAGISel.inc SystemZGenSubtarget.inc SystemZGenCallingConv.inc
-DIRS = AsmPrinter
+DIRS = AsmPrinter TargetInfo
include $(LEVEL)/Makefile.common
namespace llvm {
class SystemZTargetMachine;
class FunctionPass;
- class raw_ostream;
+ class formatted_raw_ostream;
namespace SystemZCC {
// SystemZ specific condition code. These correspond to SYSTEMZ_*_COND in
FunctionPass *createSystemZISelDag(SystemZTargetMachine &TM,
CodeGenOpt::Level OptLevel);
- FunctionPass *createSystemZCodePrinterPass(raw_ostream &o,
- SystemZTargetMachine &tm,
- CodeGenOpt::Level OptLevel,
- bool verbose);
+ FunctionPass *createSystemZCodePrinterPass(formatted_raw_ostream &o,
+ TargetMachine &tm,
+ bool verbose);
} // end namespace llvm;
#include "llvm/Target/TargetLowering.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
static const unsigned subreg_even32 = 1;
// Assign locations to all of the incoming arguments.
SmallVector<CCValAssign, 16> ArgLocs;
- CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs);
+ CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs, DAG.getContext());
CCInfo.AnalyzeFormalArguments(Op.getNode(), CC_SystemZ);
assert(!isVarArg && "Varargs not supported yet");
// Analyze operands of the call, assigning locations to each operand.
SmallVector<CCValAssign, 16> ArgLocs;
- CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs);
+ CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs, DAG.getContext());
CCInfo.AnalyzeCallOperands(TheCall, CC_SystemZ);
// Assign locations to each value returned by this call.
SmallVector<CCValAssign, 16> RVLocs;
- CCState CCInfo(CallingConv, isVarArg, getTargetMachine(), RVLocs);
+ CCState CCInfo(CallingConv, isVarArg, getTargetMachine(), RVLocs,
+ DAG.getContext());
CCInfo.AnalyzeCallResult(TheCall, RetCC_SystemZ);
SmallVector<SDValue, 8> ResultVals;
DebugLoc dl = Op.getDebugLoc();
// CCState - Info about the registers and stack slot.
- CCState CCInfo(CC, isVarArg, getTargetMachine(), RVLocs);
+ CCState CCInfo(CC, isVarArg, getTargetMachine(), RVLocs, DAG.getContext());
// Analize return values of ISD::RET
CCInfo.AnalyzeReturn(Op.getNode(), RetCC_SystemZ);
/// DAG node.
virtual const char *getTargetNodeName(unsigned Opcode) const;
+ /// getFunctionAlignment - Return the Log2 alignment of this function.
+ virtual unsigned getFunctionAlignment(const Function *F) const {
+ return 1;
+ }
+
SDValue LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG);
SDValue LowerRET(SDValue Op, SelectionDAG &DAG);
SDValue LowerCALL(SDValue Op, SelectionDAG &DAG);
#include "llvm/Target/TargetMachineRegistry.h"
using namespace llvm;
-/// SystemZTargetMachineModule - Note that this is used on hosts that
-/// cannot link in a library unless there are references into the
-/// library. In particular, it seems that it is not possible to get
-/// things to work on Win32 without this. Though it is unused, do not
-/// remove it.
-extern "C" int SystemZTargetMachineModule;
-int SystemZTargetMachineModule = 0;
+extern Target TheSystemZTarget;
+namespace {
+ // Register the target.
+ RegisterTarget<SystemZTargetMachine> X(TheSystemZTarget,
+ "systemz",
+ "SystemZ [experimental]");
+}
+
+// Force static initialization.
+extern "C" void LLVMInitializeSystemZTarget() {
-// Register the target.
-static RegisterTarget<SystemZTargetMachine>
-X("systemz", "SystemZ [experimental]");
+}
const TargetAsmInfo *SystemZTargetMachine::createTargetAsmInfo() const {
// FIXME: Handle Solaris subtarget someday :)
/// SystemZTargetMachine ctor - Create an ILP64 architecture model
///
-SystemZTargetMachine::SystemZTargetMachine(const Module &M, const std::string &FS)
- : Subtarget(*this, M, FS),
- DataLayout("E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16"),
+SystemZTargetMachine::SystemZTargetMachine(const Target &T,
+ const Module &M,
+ const std::string &FS)
+ : LLVMTargetMachine(T),
+ Subtarget(*this, M, FS),
+ DataLayout("E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
+ "-f64:64:64-f128:128:128-a0:16:16"),
InstrInfo(*this), TLInfo(*this),
FrameInfo(TargetFrameInfo::StackGrowsDown, 8, -160) {
return false;
}
-bool SystemZTargetMachine::addAssemblyEmitter(PassManagerBase &PM,
- CodeGenOpt::Level OptLevel,
- bool Verbose,
- raw_ostream &Out) {
- // Output assembly language.
- PM.add(createSystemZCodePrinterPass(Out, *this, OptLevel, Verbose));
- return false;
-}
-
unsigned SystemZTargetMachine::getModuleMatchQuality(const Module &M) {
std::string TT = M.getTargetTriple();
virtual const TargetAsmInfo *createTargetAsmInfo() const;
public:
- SystemZTargetMachine(const Module &M, const std::string &FS);
+ SystemZTargetMachine(const Target &T, const Module &M, const std::string &FS);
virtual const TargetFrameInfo *getFrameInfo() const { return &FrameInfo; }
virtual const SystemZInstrInfo *getInstrInfo() const { return &InstrInfo; }
}
virtual bool addInstSelector(PassManagerBase &PM, CodeGenOpt::Level OptLevel);
- virtual bool addAssemblyEmitter(PassManagerBase &PM,
- CodeGenOpt::Level OptLevel, bool Verbose,
- raw_ostream &Out);
static unsigned getModuleMatchQuality(const Module &M);
}; // SystemZTargetMachine.
--- /dev/null
+include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. )
+
+add_llvm_library(LLVMSystemZInfo
+ SystemZTargetInfo.cpp
+ )
+
--- /dev/null
+##===- lib/Target/SystemZ/TargetInfo/Makefile --------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../../..
+LIBRARYNAME = LLVMSystemZInfo
+
+# Hack: we need to include 'main' target directory to grab private headers
+CPPFLAGS = -I$(PROJ_OBJ_DIR)/.. -I$(PROJ_SRC_DIR)/..
+
+include $(LEVEL)/Makefile.common
--- /dev/null
+//===-- SystemZTargetInfo.cpp - SystemZ Target Implementation -----------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Module.h"
+#include "llvm/Target/TargetRegistry.h"
+using namespace llvm;
+
+Target TheSystemZTarget;
+
+static unsigned SystemZ_JITMatchQuality() {
+ return 0;
+}
+
+static unsigned SystemZ_TripleMatchQuality(const std::string &TT) {
+ // We strongly match s390x
+ if (TT.size() >= 5 && TT[0] == 's' && TT[1] == '3' && TT[2] == '9' &&
+ TT[3] == '0' && TT[4] == 'x')
+ return 20;
+
+ return 0;
+}
+
+static unsigned SystemZ_ModuleMatchQuality(const Module &M) {
+ // Check for a triple match.
+ if (unsigned Q = SystemZ_TripleMatchQuality(M.getTargetTriple()))
+ return Q;
+
+ // Otherwise we don't match.
+ return 0;
+}
+
+extern "C" void LLVMInitializeSystemZTargetInfo() {
+ TargetRegistry::RegisterTarget(TheSystemZTarget, "systemz",
+ "SystemZ",
+ &SystemZ_TripleMatchQuality,
+ &SystemZ_ModuleMatchQuality,
+ &SystemZ_JITMatchQuality);
+}
projects / oota-llvm.git / commitdiff