2013-05-07 00:15:19 +08:00
|
|
|
//===-- SystemZTargetMachine.cpp - Define TargetMachine for SystemZ -------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "SystemZTargetMachine.h"
|
|
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
#include "llvm/Support/TargetRegistry.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
extern "C" void LLVMInitializeSystemZTarget() {
|
|
|
|
// Register the target.
|
|
|
|
RegisterTargetMachine<SystemZTargetMachine> X(TheSystemZTarget);
|
|
|
|
}
|
|
|
|
|
|
|
|
SystemZTargetMachine::SystemZTargetMachine(const Target &T, StringRef TT,
|
|
|
|
StringRef CPU, StringRef FS,
|
|
|
|
const TargetOptions &Options,
|
|
|
|
Reloc::Model RM,
|
|
|
|
CodeModel::Model CM,
|
|
|
|
CodeGenOpt::Level OL)
|
|
|
|
: LLVMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL),
|
|
|
|
Subtarget(TT, CPU, FS),
|
|
|
|
// Make sure that global data has at least 16 bits of alignment by default,
|
|
|
|
// so that we can refer to it using LARL. We don't have any special
|
|
|
|
// requirements for stack variables though.
|
|
|
|
DL("E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
|
|
|
|
"-f32:32-f64:64-f128:64-a0:8:16-n32:64"),
|
|
|
|
InstrInfo(*this), TLInfo(*this), TSInfo(*this),
|
|
|
|
FrameLowering(*this, Subtarget) {
|
2013-05-13 09:16:13 +08:00
|
|
|
initAsmInfo();
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// SystemZ Code Generator Pass Configuration Options.
|
|
|
|
class SystemZPassConfig : public TargetPassConfig {
|
|
|
|
public:
|
|
|
|
SystemZPassConfig(SystemZTargetMachine *TM, PassManagerBase &PM)
|
|
|
|
: TargetPassConfig(TM, PM) {}
|
|
|
|
|
|
|
|
SystemZTargetMachine &getSystemZTargetMachine() const {
|
|
|
|
return getTM<SystemZTargetMachine>();
|
|
|
|
}
|
|
|
|
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
virtual bool addInstSelector() LLVM_OVERRIDE;
|
2013-07-25 17:11:15 +08:00
|
|
|
virtual bool addPreSched2() LLVM_OVERRIDE;
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
virtual bool addPreEmitPass() LLVM_OVERRIDE;
|
2013-05-07 00:15:19 +08:00
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
bool SystemZPassConfig::addInstSelector() {
|
|
|
|
addPass(createSystemZISelDag(getSystemZTargetMachine(), getOptLevel()));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-25 17:11:15 +08:00
|
|
|
bool SystemZPassConfig::addPreSched2() {
|
|
|
|
if (getSystemZTargetMachine().getSubtargetImpl()->hasLoadStoreOnCond())
|
|
|
|
addPass(&IfConverterID);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
bool SystemZPassConfig::addPreEmitPass() {
|
2013-08-05 18:58:53 +08:00
|
|
|
// We eliminate comparisons here rather than earlier because some
|
|
|
|
// transformations can change the set of available CC values and we
|
|
|
|
// generally want those transformations to have priority. This is
|
|
|
|
// especially true in the commonest case where the result of the comparison
|
|
|
|
// is used by a single in-range branch instruction, since we will then
|
|
|
|
// be able to fuse the compare and the branch instead.
|
|
|
|
//
|
|
|
|
// For example, two-address NILF can sometimes be converted into
|
|
|
|
// three-address RISBLG. NILF produces a CC value that indicates whether
|
|
|
|
// the low word is zero, but RISBLG does not modify CC at all. On the
|
|
|
|
// other hand, 64-bit ANDs like NILL can sometimes be converted to RISBG.
|
|
|
|
// The CC value produced by NILL isn't useful for our purposes, but the
|
|
|
|
// value produced by RISBG can be used for any comparison with zero
|
|
|
|
// (not just equality). So there are some transformations that lose
|
|
|
|
// CC values (while still being worthwhile) and others that happen to make
|
|
|
|
// the CC result more useful than it was originally.
|
|
|
|
//
|
2013-08-05 19:23:46 +08:00
|
|
|
// Another reason is that we only want to use BRANCH ON COUNT in cases
|
|
|
|
// where we know that the count register is not going to be spilled.
|
|
|
|
//
|
2013-08-05 18:58:53 +08:00
|
|
|
// Doing it so late makes it more likely that a register will be reused
|
|
|
|
// between the comparison and the branch, but it isn't clear whether
|
|
|
|
// preventing that would be a win or not.
|
|
|
|
if (getOptLevel() != CodeGenOpt::None)
|
|
|
|
addPass(createSystemZElimComparePass(getSystemZTargetMachine()));
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
addPass(createSystemZLongBranchPass(getSystemZTargetMachine()));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
TargetPassConfig *SystemZTargetMachine::createPassConfig(PassManagerBase &PM) {
|
|
|
|
return new SystemZPassConfig(this, PM);
|
|
|
|
}
|