2004-08-16 23:15:22 +00:00
|
|
|
//===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the AsmPrinter class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-03-03 02:04:29 +00:00
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
2006-03-01 22:18:09 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
Teach the SelectionDAG ISel how to turn ConstantPacked values into
constant nodes with vector types. Also teach the asm printer how to print
ConstantPacked constant pool entries. This allows us to generate altivec
code such as the following, which adds a vector constantto a packed float.
LCPI1_0: <4 x float> < float 0.0e+0, float 0.0e+0, float 0.0e+0, float 1.0e+0 >
.space 4
.space 4
.space 4
.long 1065353216 ; float 1
.text
.align 4
.globl _foo
_foo:
lis r2, ha16(LCPI1_0)
la r2, lo16(LCPI1_0)(r2)
li r4, 0
lvx v0, r4, r2
lvx v1, r4, r3
vaddfp v0, v1, v0
stvx v0, r4, r3
blr
For the llvm code:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = add <4 x float> %tmp1, < float 0.0, float 0.0, float 0.0, float 1.0 >
store <4 x float> %tmp2, <4 x float> *%a
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24616 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-06 06:18:55 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2004-08-16 23:15:22 +00:00
|
|
|
#include "llvm/Constants.h"
|
2005-11-10 18:36:17 +00:00
|
|
|
#include "llvm/Module.h"
|
2005-11-21 08:25:09 +00:00
|
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
2006-04-22 18:53:45 +00:00
|
|
|
#include "llvm/CodeGen/MachineJumpTableInfo.h"
|
2004-08-16 23:15:22 +00:00
|
|
|
#include "llvm/Support/Mangler.h"
|
2005-08-17 19:34:49 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2006-09-06 18:34:40 +00:00
|
|
|
#include "llvm/Target/TargetAsmInfo.h"
|
2006-05-12 06:33:49 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2006-10-06 22:50:56 +00:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2004-08-16 23:15:22 +00:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2005-12-28 06:29:02 +00:00
|
|
|
#include <iostream>
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
#include <cerrno>
|
2004-08-16 23:15:22 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2006-09-07 22:06:40 +00:00
|
|
|
AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm,
|
|
|
|
const TargetAsmInfo *T)
|
2006-09-06 18:34:40 +00:00
|
|
|
: FunctionNumber(0), O(o), TM(tm), TAI(T)
|
|
|
|
{}
|
2005-12-13 06:32:10 +00:00
|
|
|
|
2006-10-05 02:42:47 +00:00
|
|
|
std::string AsmPrinter::getSectionForFunction(const Function &F) const {
|
|
|
|
return TAI->getTextSection();
|
|
|
|
}
|
|
|
|
|
2005-12-13 06:32:10 +00:00
|
|
|
|
2006-05-09 04:59:56 +00:00
|
|
|
/// SwitchToTextSection - Switch to the specified text section of the executable
|
|
|
|
/// if we are not already in it!
|
2005-11-21 07:06:27 +00:00
|
|
|
///
|
2006-05-09 04:59:56 +00:00
|
|
|
void AsmPrinter::SwitchToTextSection(const char *NewSection,
|
|
|
|
const GlobalValue *GV) {
|
2005-11-21 07:06:27 +00:00
|
|
|
std::string NS;
|
2006-05-09 05:24:50 +00:00
|
|
|
if (GV && GV->hasSection())
|
2006-09-06 18:34:40 +00:00
|
|
|
NS = TAI->getSwitchToSectionDirective() + GV->getSection();
|
2006-05-09 05:24:50 +00:00
|
|
|
else
|
|
|
|
NS = NewSection;
|
|
|
|
|
|
|
|
// If we're already in this section, we're done.
|
|
|
|
if (CurrentSection == NS) return;
|
2006-05-02 03:58:45 +00:00
|
|
|
|
2006-05-09 05:33:48 +00:00
|
|
|
// Close the current section, if applicable.
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty())
|
|
|
|
O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n";
|
2006-05-02 03:58:45 +00:00
|
|
|
|
2006-05-09 05:33:48 +00:00
|
|
|
CurrentSection = NS;
|
|
|
|
|
|
|
|
if (!CurrentSection.empty())
|
2006-09-06 18:34:40 +00:00
|
|
|
O << CurrentSection << TAI->getTextSectionStartSuffix() << '\n';
|
2005-11-21 07:06:27 +00:00
|
|
|
}
|
|
|
|
|
2006-07-27 01:13:04 +00:00
|
|
|
/// SwitchToDataSection - Switch to the specified data section of the executable
|
2006-05-09 04:59:56 +00:00
|
|
|
/// if we are not already in it!
|
|
|
|
///
|
|
|
|
void AsmPrinter::SwitchToDataSection(const char *NewSection,
|
|
|
|
const GlobalValue *GV) {
|
|
|
|
std::string NS;
|
2006-05-09 05:23:12 +00:00
|
|
|
if (GV && GV->hasSection())
|
2006-09-06 18:34:40 +00:00
|
|
|
NS = TAI->getSwitchToSectionDirective() + GV->getSection();
|
2006-05-09 05:23:12 +00:00
|
|
|
else
|
|
|
|
NS = NewSection;
|
2006-05-09 04:59:56 +00:00
|
|
|
|
2006-05-09 05:23:12 +00:00
|
|
|
// If we're already in this section, we're done.
|
|
|
|
if (CurrentSection == NS) return;
|
|
|
|
|
2006-05-09 05:33:48 +00:00
|
|
|
// Close the current section, if applicable.
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty())
|
|
|
|
O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n";
|
2006-05-09 05:33:48 +00:00
|
|
|
|
|
|
|
CurrentSection = NS;
|
2006-05-09 04:59:56 +00:00
|
|
|
|
2006-05-09 05:33:48 +00:00
|
|
|
if (!CurrentSection.empty())
|
2006-09-06 18:34:40 +00:00
|
|
|
O << CurrentSection << TAI->getDataSectionStartSuffix() << '\n';
|
2006-05-09 04:59:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-16 23:15:22 +00:00
|
|
|
bool AsmPrinter::doInitialization(Module &M) {
|
2006-09-06 18:34:40 +00:00
|
|
|
Mang = new Mangler(M, TAI->getGlobalPrefix());
|
2006-01-23 23:47:53 +00:00
|
|
|
|
2006-01-24 04:16:34 +00:00
|
|
|
if (!M.getModuleInlineAsm().empty())
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getCommentString() << " Start of file scope inline assembly\n"
|
2006-01-24 04:16:34 +00:00
|
|
|
<< M.getModuleInlineAsm()
|
2006-09-06 18:34:40 +00:00
|
|
|
<< "\n" << TAI->getCommentString()
|
|
|
|
<< " End of file scope inline assembly\n";
|
2006-01-23 23:47:53 +00:00
|
|
|
|
2006-05-09 04:59:56 +00:00
|
|
|
SwitchToDataSection("", 0); // Reset back to no section.
|
2006-01-26 20:21:46 +00:00
|
|
|
|
|
|
|
if (MachineDebugInfo *DebugInfo = getAnalysisToUpdate<MachineDebugInfo>()) {
|
|
|
|
DebugInfo->AnalyzeModule(M);
|
|
|
|
}
|
|
|
|
|
2004-08-16 23:15:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AsmPrinter::doFinalization(Module &M) {
|
|
|
|
delete Mang; Mang = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-11-21 07:51:36 +00:00
|
|
|
void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
|
2004-08-16 23:15:22 +00:00
|
|
|
// What's my mangled name?
|
2005-11-10 18:36:17 +00:00
|
|
|
CurrentFnName = Mang->getValueName(MF.getFunction());
|
2005-11-21 08:13:27 +00:00
|
|
|
IncrementFunctionNumber();
|
2004-08-16 23:15:22 +00:00
|
|
|
}
|
|
|
|
|
2005-11-21 08:25:09 +00:00
|
|
|
/// EmitConstantPool - Print to the current output stream assembly
|
|
|
|
/// representations of the constants in the constant pool MCP. This is
|
|
|
|
/// used to print out constants which have been "spilled to memory" by
|
|
|
|
/// the code generator.
|
|
|
|
///
|
|
|
|
void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) {
|
2006-02-09 04:22:52 +00:00
|
|
|
const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
|
2005-11-21 08:25:09 +00:00
|
|
|
if (CP.empty()) return;
|
2006-06-29 00:26:09 +00:00
|
|
|
|
|
|
|
// Some targets require 4-, 8-, and 16- byte constant literals to be placed
|
|
|
|
// in special sections.
|
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > FourByteCPs;
|
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > EightByteCPs;
|
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > SixteenByteCPs;
|
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > OtherCPs;
|
2006-09-12 21:00:35 +00:00
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > TargetCPs;
|
2006-06-29 00:26:09 +00:00
|
|
|
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
|
|
|
|
MachineConstantPoolEntry CPE = CP[i];
|
2006-09-14 07:35:00 +00:00
|
|
|
const Type *Ty = CPE.getType();
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getFourByteConstantSection() &&
|
2006-06-29 00:26:09 +00:00
|
|
|
TM.getTargetData()->getTypeSize(Ty) == 4)
|
|
|
|
FourByteCPs.push_back(std::make_pair(CPE, i));
|
2006-09-07 18:50:20 +00:00
|
|
|
else if (TAI->getEightByteConstantSection() &&
|
2006-06-29 00:26:09 +00:00
|
|
|
TM.getTargetData()->getTypeSize(Ty) == 8)
|
|
|
|
EightByteCPs.push_back(std::make_pair(CPE, i));
|
2006-09-07 18:50:20 +00:00
|
|
|
else if (TAI->getSixteenByteConstantSection() &&
|
2006-06-29 00:26:09 +00:00
|
|
|
TM.getTargetData()->getTypeSize(Ty) == 16)
|
|
|
|
SixteenByteCPs.push_back(std::make_pair(CPE, i));
|
|
|
|
else
|
|
|
|
OtherCPs.push_back(std::make_pair(CPE, i));
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned Alignment = MCP->getConstantPoolAlignment();
|
2006-09-06 18:34:40 +00:00
|
|
|
EmitConstantPool(Alignment, TAI->getFourByteConstantSection(), FourByteCPs);
|
|
|
|
EmitConstantPool(Alignment, TAI->getEightByteConstantSection(), EightByteCPs);
|
|
|
|
EmitConstantPool(Alignment, TAI->getSixteenByteConstantSection(),
|
|
|
|
SixteenByteCPs);
|
|
|
|
EmitConstantPool(Alignment, TAI->getConstantPoolSection(), OtherCPs);
|
2006-06-29 00:26:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section,
|
|
|
|
std::vector<std::pair<MachineConstantPoolEntry,unsigned> > &CP) {
|
|
|
|
if (CP.empty()) return;
|
|
|
|
|
|
|
|
SwitchToDataSection(Section, 0);
|
|
|
|
EmitAlignment(Alignment);
|
2005-11-21 08:25:09 +00:00
|
|
|
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
|
|
|
|
<< CP[i].second << ":\t\t\t\t\t" << TAI->getCommentString() << " ";
|
2006-09-14 07:35:00 +00:00
|
|
|
WriteTypeSymbolic(O, CP[i].first.getType(), 0) << '\n';
|
|
|
|
if (CP[i].first.isMachineConstantPoolEntry())
|
2006-09-12 21:00:35 +00:00
|
|
|
EmitMachineConstantPoolValue(CP[i].first.Val.MachineCPVal);
|
2006-09-14 07:35:00 +00:00
|
|
|
else
|
2006-09-12 21:00:35 +00:00
|
|
|
EmitGlobalConstant(CP[i].first.Val.ConstVal);
|
2006-02-09 04:46:04 +00:00
|
|
|
if (i != e-1) {
|
2006-09-14 07:35:00 +00:00
|
|
|
const Type *Ty = CP[i].first.getType();
|
2006-06-29 00:26:09 +00:00
|
|
|
unsigned EntSize =
|
2006-09-12 21:00:35 +00:00
|
|
|
TM.getTargetData()->getTypeSize(Ty);
|
2006-09-14 07:35:00 +00:00
|
|
|
unsigned ValEnd = CP[i].first.getOffset() + EntSize;
|
2006-02-09 04:46:04 +00:00
|
|
|
// Emit inter-object padding for alignment.
|
2006-09-14 07:35:00 +00:00
|
|
|
EmitZeros(CP[i+1].first.getOffset()-ValEnd);
|
2006-02-09 04:46:04 +00:00
|
|
|
}
|
2005-11-21 08:25:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
/// EmitJumpTableInfo - Print assembly representations of the jump tables used
|
|
|
|
/// by the current function to the current output stream.
|
|
|
|
///
|
2006-10-05 03:01:21 +00:00
|
|
|
void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI,
|
|
|
|
MachineFunction &MF) {
|
2006-04-22 18:53:45 +00:00
|
|
|
const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
|
|
|
|
if (JT.empty()) return;
|
2006-05-03 01:29:57 +00:00
|
|
|
const TargetData *TD = TM.getTargetData();
|
2006-07-27 16:46:58 +00:00
|
|
|
|
|
|
|
// JTEntryDirective is a string to print sizeof(ptr) for non-PIC jump tables,
|
|
|
|
// and 32 bits for PIC since PIC jump table entries are differences, not
|
|
|
|
// pointers to blocks.
|
2006-09-24 19:45:58 +00:00
|
|
|
// Use the architecture specific relocation directive, if it is set
|
|
|
|
const char *JTEntryDirective = TAI->getJumpTableDirective();
|
|
|
|
if (!JTEntryDirective)
|
|
|
|
JTEntryDirective = TAI->getData32bitsDirective();
|
2006-04-22 18:53:45 +00:00
|
|
|
|
2006-07-27 01:13:04 +00:00
|
|
|
// Pick the directive to use to print the jump table entries, and switch to
|
|
|
|
// the appropriate section.
|
|
|
|
if (TM.getRelocationModel() == Reloc::PIC_) {
|
2006-10-06 22:50:56 +00:00
|
|
|
TargetLowering *LoweringInfo = TM.getTargetLowering();
|
|
|
|
if (LoweringInfo && LoweringInfo->usesGlobalOffsetTable()) {
|
|
|
|
SwitchToDataSection(TAI->getJumpTableDataSection(), 0);
|
2006-10-11 04:29:42 +00:00
|
|
|
if (TD->getPointerSize() == 8 && !JTEntryDirective)
|
2006-10-06 22:50:56 +00:00
|
|
|
JTEntryDirective = TAI->getData64bitsDirective();
|
|
|
|
} else {
|
|
|
|
// In PIC mode, we need to emit the jump table to the same section as the
|
|
|
|
// function body itself, otherwise the label differences won't make sense.
|
|
|
|
const Function *F = MF.getFunction();
|
|
|
|
SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
|
|
|
|
}
|
2006-07-27 01:13:04 +00:00
|
|
|
} else {
|
2006-09-06 18:34:40 +00:00
|
|
|
SwitchToDataSection(TAI->getJumpTableDataSection(), 0);
|
2006-07-27 01:13:04 +00:00
|
|
|
if (TD->getPointerSize() == 8)
|
2006-09-06 18:34:40 +00:00
|
|
|
JTEntryDirective = TAI->getData64bitsDirective();
|
2006-07-27 01:13:04 +00:00
|
|
|
}
|
2006-05-03 01:29:57 +00:00
|
|
|
EmitAlignment(Log2_32(TD->getPointerAlignment()));
|
2006-07-15 01:34:12 +00:00
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
for (unsigned i = 0, e = JT.size(); i != e; ++i) {
|
2006-08-12 21:29:52 +00:00
|
|
|
const std::vector<MachineBasicBlock*> &JTBBs = JT[i].MBBs;
|
|
|
|
|
|
|
|
// For PIC codegen, if possible we want to use the SetDirective to reduce
|
|
|
|
// the number of relocations the assembler will generate for the jump table.
|
|
|
|
// Set directives are all printed before the jump table itself.
|
|
|
|
std::set<MachineBasicBlock*> EmittedSets;
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getSetDirective() && TM.getRelocationModel() == Reloc::PIC_)
|
2006-08-12 21:29:52 +00:00
|
|
|
for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii)
|
|
|
|
if (EmittedSets.insert(JTBBs[ii]).second)
|
|
|
|
printSetLabel(i, JTBBs[ii]);
|
|
|
|
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
|
|
|
|
<< '_' << i << ":\n";
|
2006-08-12 21:29:52 +00:00
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) {
|
2006-07-27 16:46:58 +00:00
|
|
|
O << JTEntryDirective << ' ';
|
2006-08-12 21:29:52 +00:00
|
|
|
// If we have emitted set directives for the jump table entries, print
|
|
|
|
// them rather than the entries themselves. If we're emitting PIC, then
|
|
|
|
// emit the table entries as differences between two text section labels.
|
|
|
|
// If we're emitting non-PIC code, then emit the entries as direct
|
|
|
|
// references to the target basic blocks.
|
|
|
|
if (!EmittedSets.empty()) {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
|
|
|
|
<< '_' << i << "_set_" << JTBBs[ii]->getNumber();
|
2006-08-12 21:29:52 +00:00
|
|
|
} else if (TM.getRelocationModel() == Reloc::PIC_) {
|
|
|
|
printBasicBlockLabel(JTBBs[ii], false, false);
|
2006-09-24 19:45:58 +00:00
|
|
|
//If the arch uses custom Jump Table directives, don't calc relative to JT
|
|
|
|
if (!TAI->getJumpTableDirective())
|
|
|
|
O << '-' << TAI->getPrivateGlobalPrefix() << "JTI"
|
|
|
|
<< getFunctionNumber() << '_' << i;
|
2006-08-12 21:29:52 +00:00
|
|
|
} else {
|
|
|
|
printBasicBlockLabel(JTBBs[ii], false, false);
|
2006-07-27 01:13:04 +00:00
|
|
|
}
|
2006-04-22 18:53:45 +00:00
|
|
|
O << '\n';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-13 06:32:10 +00:00
|
|
|
/// EmitSpecialLLVMGlobal - Check to see if the specified global is a
|
|
|
|
/// special global used by LLVM. If so, emit it and return true, otherwise
|
|
|
|
/// do nothing and return false.
|
|
|
|
bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) {
|
2006-03-07 22:00:35 +00:00
|
|
|
// Ignore debug and non-emitted data.
|
|
|
|
if (GV->getSection() == "llvm.metadata") return true;
|
|
|
|
|
|
|
|
if (!GV->hasAppendingLinkage()) return false;
|
|
|
|
|
|
|
|
assert(GV->hasInitializer() && "Not a special LLVM global!");
|
2005-12-13 06:32:10 +00:00
|
|
|
|
2006-09-26 03:38:18 +00:00
|
|
|
if (GV->getName() == "llvm.used") {
|
|
|
|
if (TAI->getUsedDirective() != 0) // No need to emit this at all.
|
|
|
|
EmitLLVMUsedList(GV->getInitializer());
|
|
|
|
return true;
|
|
|
|
}
|
2005-12-13 06:32:10 +00:00
|
|
|
|
2006-01-12 19:17:23 +00:00
|
|
|
if (GV->getName() == "llvm.global_ctors" && GV->use_empty()) {
|
2006-09-06 18:34:40 +00:00
|
|
|
SwitchToDataSection(TAI->getStaticCtorsSection(), 0);
|
2005-12-13 06:32:10 +00:00
|
|
|
EmitAlignment(2, 0);
|
|
|
|
EmitXXStructorList(GV->getInitializer());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-01-12 19:17:23 +00:00
|
|
|
if (GV->getName() == "llvm.global_dtors" && GV->use_empty()) {
|
2006-09-06 18:34:40 +00:00
|
|
|
SwitchToDataSection(TAI->getStaticDtorsSection(), 0);
|
2005-12-13 06:32:10 +00:00
|
|
|
EmitAlignment(2, 0);
|
|
|
|
EmitXXStructorList(GV->getInitializer());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-09-26 03:38:18 +00:00
|
|
|
/// EmitLLVMUsedList - For targets that define a TAI::UsedDirective, mark each
|
|
|
|
/// global in the specified llvm.used list as being used with this directive.
|
|
|
|
void AsmPrinter::EmitLLVMUsedList(Constant *List) {
|
|
|
|
const char *Directive = TAI->getUsedDirective();
|
|
|
|
|
|
|
|
// Should be an array of 'sbyte*'.
|
|
|
|
ConstantArray *InitList = dyn_cast<ConstantArray>(List);
|
|
|
|
if (InitList == 0) return;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
|
|
|
|
O << Directive;
|
|
|
|
EmitConstantValueOnly(InitList->getOperand(i));
|
|
|
|
O << "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-13 06:32:10 +00:00
|
|
|
/// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the
|
|
|
|
/// function pointers, ignoring the init priority.
|
|
|
|
void AsmPrinter::EmitXXStructorList(Constant *List) {
|
|
|
|
// Should be an array of '{ int, void ()* }' structs. The first value is the
|
|
|
|
// init priority, which we ignore.
|
|
|
|
if (!isa<ConstantArray>(List)) return;
|
|
|
|
ConstantArray *InitList = cast<ConstantArray>(List);
|
|
|
|
for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
|
|
|
|
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
|
|
|
|
if (CS->getNumOperands() != 2) return; // Not array of 2-element structs.
|
2005-12-21 01:17:37 +00:00
|
|
|
|
|
|
|
if (CS->getOperand(1)->isNullValue())
|
|
|
|
return; // Found a null terminator, exit printing.
|
|
|
|
// Emit the function pointer.
|
2005-12-13 06:32:10 +00:00
|
|
|
EmitGlobalConstant(CS->getOperand(1));
|
|
|
|
}
|
|
|
|
}
|
2005-11-21 08:25:09 +00:00
|
|
|
|
2006-02-05 01:29:18 +00:00
|
|
|
/// getPreferredAlignmentLog - Return the preferred alignment of the
|
|
|
|
/// specified global, returned in log form. This includes an explicitly
|
|
|
|
/// requested alignment (if the global has one).
|
|
|
|
unsigned AsmPrinter::getPreferredAlignmentLog(const GlobalVariable *GV) const {
|
2006-06-15 13:10:58 +00:00
|
|
|
const Type *ElemType = GV->getType()->getElementType();
|
|
|
|
unsigned Alignment = TM.getTargetData()->getTypeAlignmentShift(ElemType);
|
2006-02-05 01:29:18 +00:00
|
|
|
if (GV->getAlignment() > (1U << Alignment))
|
|
|
|
Alignment = Log2_32(GV->getAlignment());
|
|
|
|
|
2006-02-05 01:46:49 +00:00
|
|
|
if (GV->hasInitializer()) {
|
2006-06-15 19:37:14 +00:00
|
|
|
// Always round up alignment of global doubles to 8 bytes.
|
|
|
|
if (GV->getType()->getElementType() == Type::DoubleTy && Alignment < 3)
|
|
|
|
Alignment = 3;
|
2006-02-05 01:46:49 +00:00
|
|
|
if (Alignment < 4) {
|
|
|
|
// If the global is not external, see if it is large. If so, give it a
|
|
|
|
// larger alignment.
|
2006-06-15 13:10:58 +00:00
|
|
|
if (TM.getTargetData()->getTypeSize(ElemType) > 128)
|
2006-02-05 01:46:49 +00:00
|
|
|
Alignment = 4; // 16-byte alignment.
|
|
|
|
}
|
2006-02-05 01:29:18 +00:00
|
|
|
}
|
|
|
|
return Alignment;
|
|
|
|
}
|
2005-11-21 08:25:09 +00:00
|
|
|
|
2006-10-17 13:41:07 +00:00
|
|
|
/// getGlobalLinkName - Returns the asm/link name of of the specified
|
|
|
|
/// global variable. Should be overridden by each target asm printer to
|
|
|
|
/// generate the appropriate value.
|
2006-10-17 17:17:24 +00:00
|
|
|
const std::string AsmPrinter::getGlobalLinkName(const GlobalVariable *GV) const{
|
|
|
|
std::string LinkName;
|
2006-10-17 13:41:07 +00:00
|
|
|
// Default action is to use a global symbol.
|
|
|
|
LinkName = TAI->getGlobalPrefix();
|
|
|
|
LinkName += GV->getName();
|
2006-10-17 17:17:24 +00:00
|
|
|
return LinkName;
|
2006-10-17 13:41:07 +00:00
|
|
|
}
|
|
|
|
|
2005-11-21 07:51:36 +00:00
|
|
|
// EmitAlignment - Emit an alignment directive to the specified power of two.
|
|
|
|
void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const {
|
2005-11-14 19:00:06 +00:00
|
|
|
if (GV && GV->getAlignment())
|
|
|
|
NumBits = Log2_32(GV->getAlignment());
|
2005-11-10 18:09:27 +00:00
|
|
|
if (NumBits == 0) return; // No need to emit alignment.
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getAlignmentIsInBytes()) NumBits = 1 << NumBits;
|
|
|
|
O << TAI->getAlignDirective() << NumBits << "\n";
|
2004-08-17 19:14:29 +00:00
|
|
|
}
|
|
|
|
|
2005-11-21 07:51:36 +00:00
|
|
|
/// EmitZeros - Emit a block of zeros.
|
2004-08-17 21:38:40 +00:00
|
|
|
///
|
2005-11-21 07:51:36 +00:00
|
|
|
void AsmPrinter::EmitZeros(uint64_t NumZeros) const {
|
2004-08-17 21:38:40 +00:00
|
|
|
if (NumZeros) {
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getZeroDirective()) {
|
|
|
|
O << TAI->getZeroDirective() << NumZeros;
|
|
|
|
if (TAI->getZeroDirectiveSuffix())
|
|
|
|
O << TAI->getZeroDirectiveSuffix();
|
2006-05-02 03:46:13 +00:00
|
|
|
O << "\n";
|
|
|
|
} else {
|
2004-08-17 21:38:40 +00:00
|
|
|
for (; NumZeros; --NumZeros)
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData8bitsDirective() << "0\n";
|
2004-08-17 21:38:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-16 23:15:22 +00:00
|
|
|
// Print out the specified constant, without a storage class. Only the
|
|
|
|
// constants valid in constant expressions can occur here.
|
2005-11-21 07:51:36 +00:00
|
|
|
void AsmPrinter::EmitConstantValueOnly(const Constant *CV) {
|
2004-10-16 18:19:26 +00:00
|
|
|
if (CV->isNullValue() || isa<UndefValue>(CV))
|
2004-08-16 23:15:22 +00:00
|
|
|
O << "0";
|
|
|
|
else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
|
2006-09-28 23:17:41 +00:00
|
|
|
assert(CB->getValue());
|
2004-08-16 23:15:22 +00:00
|
|
|
O << "1";
|
|
|
|
} else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV))
|
|
|
|
if (((CI->getValue() << 32) >> 32) == CI->getValue())
|
|
|
|
O << CI->getValue();
|
|
|
|
else
|
2005-05-15 13:05:48 +00:00
|
|
|
O << (uint64_t)CI->getValue();
|
2004-08-16 23:15:22 +00:00
|
|
|
else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
|
|
|
|
O << CI->getValue();
|
2005-11-10 18:36:17 +00:00
|
|
|
else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
|
2005-04-02 12:21:51 +00:00
|
|
|
// This is a constant address for a global variable or function. Use the
|
|
|
|
// name of the variable or function as the address value, possibly
|
|
|
|
// decorating it with GlobalVarAddrPrefix/Suffix or
|
|
|
|
// FunctionAddrPrefix/Suffix (these all default to "" )
|
2006-09-06 18:34:40 +00:00
|
|
|
if (isa<Function>(GV)) {
|
|
|
|
O << TAI->getFunctionAddrPrefix()
|
|
|
|
<< Mang->getValueName(GV)
|
|
|
|
<< TAI->getFunctionAddrSuffix();
|
|
|
|
} else {
|
|
|
|
O << TAI->getGlobalVarAddrPrefix()
|
|
|
|
<< Mang->getValueName(GV)
|
|
|
|
<< TAI->getGlobalVarAddrSuffix();
|
|
|
|
}
|
2005-04-02 12:21:51 +00:00
|
|
|
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
|
2006-05-03 01:29:57 +00:00
|
|
|
const TargetData *TD = TM.getTargetData();
|
2004-08-16 23:15:22 +00:00
|
|
|
switch(CE->getOpcode()) {
|
|
|
|
case Instruction::GetElementPtr: {
|
|
|
|
// generate a symbolic expression for the byte address
|
|
|
|
const Constant *ptrVal = CE->getOperand(0);
|
|
|
|
std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
|
2006-05-03 01:29:57 +00:00
|
|
|
if (int64_t Offset = TD->getIndexedOffset(ptrVal->getType(), idxVec)) {
|
2005-02-14 21:40:26 +00:00
|
|
|
if (Offset)
|
|
|
|
O << "(";
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(ptrVal);
|
2005-02-14 21:40:26 +00:00
|
|
|
if (Offset > 0)
|
|
|
|
O << ") + " << Offset;
|
|
|
|
else if (Offset < 0)
|
|
|
|
O << ") - " << -Offset;
|
2004-08-16 23:15:22 +00:00
|
|
|
} else {
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(ptrVal);
|
2004-08-16 23:15:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Instruction::Cast: {
|
2006-07-29 01:57:19 +00:00
|
|
|
// Support only foldable casts to/from pointers that can be eliminated by
|
|
|
|
// changing the pointer to the appropriately sized integer type.
|
2004-08-16 23:15:22 +00:00
|
|
|
Constant *Op = CE->getOperand(0);
|
|
|
|
const Type *OpTy = Op->getType(), *Ty = CE->getType();
|
|
|
|
|
2006-07-29 01:57:19 +00:00
|
|
|
// Handle casts to pointers by changing them into casts to the appropriate
|
|
|
|
// integer type. This promotes constant folding and simplifies this code.
|
|
|
|
if (isa<PointerType>(Ty)) {
|
|
|
|
const Type *IntPtrTy = TD->getIntPtrType();
|
|
|
|
Op = ConstantExpr::getCast(Op, IntPtrTy);
|
|
|
|
return EmitConstantValueOnly(Op);
|
|
|
|
}
|
|
|
|
|
|
|
|
// We know the dest type is not a pointer. Is the src value a pointer or
|
|
|
|
// integral?
|
|
|
|
if (isa<PointerType>(OpTy) || OpTy->isIntegral()) {
|
|
|
|
// We can emit the pointer value into this slot if the slot is an
|
|
|
|
// integer slot greater or equal to the size of the pointer.
|
|
|
|
if (Ty->isIntegral() && TD->getTypeSize(Ty) >= TD->getTypeSize(OpTy))
|
|
|
|
return EmitConstantValueOnly(Op);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(0 && "FIXME: Don't yet support this kind of constant cast expr");
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(Op);
|
2004-08-16 23:15:22 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Instruction::Add:
|
|
|
|
O << "(";
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(CE->getOperand(0));
|
2004-08-16 23:15:22 +00:00
|
|
|
O << ") + (";
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(CE->getOperand(1));
|
2004-08-16 23:15:22 +00:00
|
|
|
O << ")";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0 && "Unsupported operator!");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
assert(0 && "Unknown constant value!");
|
|
|
|
}
|
|
|
|
}
|
2004-08-17 06:36:49 +00:00
|
|
|
|
|
|
|
/// toOctal - Convert the low order bits of X into an octal digit.
|
|
|
|
///
|
|
|
|
static inline char toOctal(int X) {
|
|
|
|
return (X&7)+'0';
|
|
|
|
}
|
|
|
|
|
2005-11-10 18:06:33 +00:00
|
|
|
/// printAsCString - Print the specified array as a C compatible string, only if
|
2004-08-17 06:36:49 +00:00
|
|
|
/// the predicate isString is true.
|
|
|
|
///
|
2005-11-10 18:06:33 +00:00
|
|
|
static void printAsCString(std::ostream &O, const ConstantArray *CVA,
|
|
|
|
unsigned LastElt) {
|
2004-08-17 06:36:49 +00:00
|
|
|
assert(CVA->isString() && "Array is not string compatible!");
|
|
|
|
|
|
|
|
O << "\"";
|
2005-11-10 18:06:33 +00:00
|
|
|
for (unsigned i = 0; i != LastElt; ++i) {
|
2005-04-21 22:36:52 +00:00
|
|
|
unsigned char C =
|
2005-01-08 19:59:10 +00:00
|
|
|
(unsigned char)cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
|
2004-08-17 06:36:49 +00:00
|
|
|
|
|
|
|
if (C == '"') {
|
|
|
|
O << "\\\"";
|
|
|
|
} else if (C == '\\') {
|
|
|
|
O << "\\\\";
|
|
|
|
} else if (isprint(C)) {
|
|
|
|
O << C;
|
|
|
|
} else {
|
|
|
|
switch(C) {
|
|
|
|
case '\b': O << "\\b"; break;
|
|
|
|
case '\f': O << "\\f"; break;
|
|
|
|
case '\n': O << "\\n"; break;
|
|
|
|
case '\r': O << "\\r"; break;
|
|
|
|
case '\t': O << "\\t"; break;
|
|
|
|
default:
|
|
|
|
O << '\\';
|
|
|
|
O << toOctal(C >> 6);
|
|
|
|
O << toOctal(C >> 3);
|
|
|
|
O << toOctal(C >> 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
O << "\"";
|
|
|
|
}
|
|
|
|
|
2006-05-02 01:16:28 +00:00
|
|
|
/// EmitString - Emit a zero-byte-terminated string constant.
|
|
|
|
///
|
|
|
|
void AsmPrinter::EmitString(const ConstantArray *CVA) const {
|
|
|
|
unsigned NumElts = CVA->getNumOperands();
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getAscizDirective() && NumElts &&
|
2006-05-02 01:16:28 +00:00
|
|
|
cast<ConstantInt>(CVA->getOperand(NumElts-1))->getRawValue() == 0) {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getAscizDirective();
|
2006-05-02 01:16:28 +00:00
|
|
|
printAsCString(O, CVA, NumElts-1);
|
|
|
|
} else {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getAsciiDirective();
|
2006-05-02 01:16:28 +00:00
|
|
|
printAsCString(O, CVA, NumElts);
|
|
|
|
}
|
|
|
|
O << "\n";
|
|
|
|
}
|
|
|
|
|
2005-11-21 07:51:36 +00:00
|
|
|
/// EmitGlobalConstant - Print a general LLVM constant to the .s file.
|
2004-08-17 06:36:49 +00:00
|
|
|
///
|
2005-11-21 07:51:36 +00:00
|
|
|
void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
|
2006-05-03 01:29:57 +00:00
|
|
|
const TargetData *TD = TM.getTargetData();
|
2004-08-17 06:36:49 +00:00
|
|
|
|
2004-10-16 18:19:26 +00:00
|
|
|
if (CV->isNullValue() || isa<UndefValue>(CV)) {
|
2006-05-03 01:29:57 +00:00
|
|
|
EmitZeros(TD->getTypeSize(CV->getType()));
|
2004-08-17 06:36:49 +00:00
|
|
|
return;
|
|
|
|
} else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
|
|
|
|
if (CVA->isString()) {
|
2006-05-02 01:16:28 +00:00
|
|
|
EmitString(CVA);
|
2004-08-17 06:36:49 +00:00
|
|
|
} else { // Not a string. Print the values in successive locations
|
|
|
|
for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i)
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitGlobalConstant(CVA->getOperand(i));
|
2004-08-17 06:36:49 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
|
|
|
|
// Print the fields in successive locations. Pad to align if needed!
|
2006-05-03 01:29:57 +00:00
|
|
|
const StructLayout *cvsLayout = TD->getStructLayout(CVS->getType());
|
2005-01-08 19:59:10 +00:00
|
|
|
uint64_t sizeSoFar = 0;
|
2004-08-17 06:36:49 +00:00
|
|
|
for (unsigned i = 0, e = CVS->getNumOperands(); i != e; ++i) {
|
|
|
|
const Constant* field = CVS->getOperand(i);
|
|
|
|
|
|
|
|
// Check if padding is needed and insert one or more 0s.
|
2006-05-03 01:29:57 +00:00
|
|
|
uint64_t fieldSize = TD->getTypeSize(field->getType());
|
2005-01-08 19:59:10 +00:00
|
|
|
uint64_t padSize = ((i == e-1? cvsLayout->StructSize
|
2004-08-17 06:36:49 +00:00
|
|
|
: cvsLayout->MemberOffsets[i+1])
|
|
|
|
- cvsLayout->MemberOffsets[i]) - fieldSize;
|
|
|
|
sizeSoFar += fieldSize + padSize;
|
|
|
|
|
|
|
|
// Now print the actual field value
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitGlobalConstant(field);
|
2004-08-17 06:36:49 +00:00
|
|
|
|
|
|
|
// Insert the field padding unless it's zero bytes...
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitZeros(padSize);
|
2004-08-17 06:36:49 +00:00
|
|
|
}
|
|
|
|
assert(sizeSoFar == cvsLayout->StructSize &&
|
|
|
|
"Layout of constant struct may be incorrect!");
|
|
|
|
return;
|
|
|
|
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
|
|
|
|
// FP Constants are printed as integer constants to avoid losing
|
|
|
|
// precision...
|
|
|
|
double Val = CFP->getValue();
|
|
|
|
if (CFP->getType() == Type::DoubleTy) {
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getData64bitsDirective())
|
|
|
|
O << TAI->getData64bitsDirective() << DoubleToBits(Val) << "\t"
|
|
|
|
<< TAI->getCommentString() << " double value: " << Val << "\n";
|
2006-05-03 01:29:57 +00:00
|
|
|
else if (TD->isBigEndian()) {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " double most significant word " << Val << "\n";
|
|
|
|
O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " double least significant word " << Val << "\n";
|
2004-08-17 06:36:49 +00:00
|
|
|
} else {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " double least significant word " << Val << "\n";
|
|
|
|
O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " double most significant word " << Val << "\n";
|
2004-08-17 06:36:49 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData32bitsDirective() << FloatToBits(Val)
|
|
|
|
<< "\t" << TAI->getCommentString() << " float " << Val << "\n";
|
2004-08-17 06:36:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (CV->getType() == Type::ULongTy || CV->getType() == Type::LongTy) {
|
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
|
|
|
|
uint64_t Val = CI->getRawValue();
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2006-09-06 18:34:40 +00:00
|
|
|
if (TAI->getData64bitsDirective())
|
|
|
|
O << TAI->getData64bitsDirective() << Val << "\n";
|
2006-05-03 01:29:57 +00:00
|
|
|
else if (TD->isBigEndian()) {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData32bitsDirective() << unsigned(Val >> 32)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " Double-word most significant word " << Val << "\n";
|
|
|
|
O << TAI->getData32bitsDirective() << unsigned(Val)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " Double-word least significant word " << Val << "\n";
|
2004-08-17 06:36:49 +00:00
|
|
|
} else {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getData32bitsDirective() << unsigned(Val)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " Double-word least significant word " << Val << "\n";
|
|
|
|
O << TAI->getData32bitsDirective() << unsigned(Val >> 32)
|
|
|
|
<< "\t" << TAI->getCommentString()
|
|
|
|
<< " Double-word most significant word " << Val << "\n";
|
2004-08-17 06:36:49 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
Teach the SelectionDAG ISel how to turn ConstantPacked values into
constant nodes with vector types. Also teach the asm printer how to print
ConstantPacked constant pool entries. This allows us to generate altivec
code such as the following, which adds a vector constantto a packed float.
LCPI1_0: <4 x float> < float 0.0e+0, float 0.0e+0, float 0.0e+0, float 1.0e+0 >
.space 4
.space 4
.space 4
.long 1065353216 ; float 1
.text
.align 4
.globl _foo
_foo:
lis r2, ha16(LCPI1_0)
la r2, lo16(LCPI1_0)(r2)
li r4, 0
lvx v0, r4, r2
lvx v1, r4, r3
vaddfp v0, v1, v0
stvx v0, r4, r3
blr
For the llvm code:
void %foo(<4 x float> * %a) {
entry:
%tmp1 = load <4 x float> * %a;
%tmp2 = add <4 x float> %tmp1, < float 0.0, float 0.0, float 0.0, float 1.0 >
store <4 x float> %tmp2, <4 x float> *%a
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24616 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-06 06:18:55 +00:00
|
|
|
} else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) {
|
|
|
|
const PackedType *PTy = CP->getType();
|
|
|
|
|
|
|
|
for (unsigned I = 0, E = PTy->getNumElements(); I < E; ++I)
|
|
|
|
EmitGlobalConstant(CP->getOperand(I));
|
|
|
|
|
|
|
|
return;
|
2004-08-17 06:36:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const Type *type = CV->getType();
|
2006-09-12 21:00:35 +00:00
|
|
|
printDataDirective(type);
|
2005-11-21 07:51:36 +00:00
|
|
|
EmitConstantValueOnly(CV);
|
2004-08-17 06:36:49 +00:00
|
|
|
O << "\n";
|
|
|
|
}
|
2006-01-27 02:10:10 +00:00
|
|
|
|
2006-09-12 21:00:35 +00:00
|
|
|
void
|
|
|
|
AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
|
|
|
|
// Target doesn't support this yet!
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2006-09-26 23:59:50 +00:00
|
|
|
/// PrintSpecial - Print information related to the specified machine instr
|
|
|
|
/// that is independent of the operand, and may be independent of the instr
|
|
|
|
/// itself. This can be useful for portably encoding the comment character
|
|
|
|
/// or other bits of target-specific knowledge into the asmstrings. The
|
|
|
|
/// syntax used is ${:comment}. Targets can override this to add support
|
|
|
|
/// for their own strange codes.
|
|
|
|
void AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) {
|
2006-09-27 00:06:07 +00:00
|
|
|
if (!strcmp(Code, "private")) {
|
|
|
|
O << TAI->getPrivateGlobalPrefix();
|
|
|
|
} else if (!strcmp(Code, "comment")) {
|
2006-09-26 23:59:50 +00:00
|
|
|
O << TAI->getCommentString();
|
|
|
|
} else if (!strcmp(Code, "uid")) {
|
|
|
|
// Assign a unique ID to this machine instruction.
|
|
|
|
static const MachineInstr *LastMI = 0;
|
|
|
|
static unsigned Counter = 0U-1;
|
|
|
|
// If this is a new machine instruction, bump the counter.
|
|
|
|
if (LastMI != MI) { ++Counter; LastMI = MI; }
|
|
|
|
O << Counter;
|
|
|
|
} else {
|
|
|
|
std::cerr << "Unknown special formatter '" << Code
|
|
|
|
<< "' for machine instr: " << *MI;
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-27 02:10:10 +00:00
|
|
|
/// printInlineAsm - This method formats and prints the specified machine
|
|
|
|
/// instruction that is an inline asm.
|
|
|
|
void AsmPrinter::printInlineAsm(const MachineInstr *MI) const {
|
2006-01-30 23:00:08 +00:00
|
|
|
unsigned NumOperands = MI->getNumOperands();
|
|
|
|
|
|
|
|
// Count the number of register definitions.
|
|
|
|
unsigned NumDefs = 0;
|
2006-09-05 20:02:51 +00:00
|
|
|
for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef();
|
|
|
|
++NumDefs)
|
2006-01-30 23:00:08 +00:00
|
|
|
assert(NumDefs != NumOperands-1 && "No asm string?");
|
|
|
|
|
|
|
|
assert(MI->getOperand(NumDefs).isExternalSymbol() && "No asm string?");
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
|
|
|
|
// Disassemble the AsmStr, printing out the literal pieces, the operands, etc.
|
2006-01-30 23:00:08 +00:00
|
|
|
const char *AsmStr = MI->getOperand(NumDefs).getSymbolName();
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
|
2006-07-28 00:17:20 +00:00
|
|
|
// If this asmstr is empty, don't bother printing the #APP/#NOAPP markers.
|
|
|
|
if (AsmStr[0] == 0) {
|
|
|
|
O << "\n"; // Tab already printed, avoid double indenting next instr.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getInlineAsmStart() << "\n\t";
|
2006-07-28 00:17:20 +00:00
|
|
|
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
// The variant of the current asmprinter: FIXME: change.
|
|
|
|
int AsmPrinterVariant = 0;
|
2006-01-30 23:00:08 +00:00
|
|
|
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
int CurVariant = -1; // The number of the {.|.|.} region we are in.
|
|
|
|
const char *LastEmitted = AsmStr; // One past the last character emitted.
|
2006-02-01 01:28:23 +00:00
|
|
|
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
while (*LastEmitted) {
|
|
|
|
switch (*LastEmitted) {
|
|
|
|
default: {
|
|
|
|
// Not a special case, emit the string section literally.
|
|
|
|
const char *LiteralEnd = LastEmitted+1;
|
|
|
|
while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' &&
|
2006-05-05 21:47:05 +00:00
|
|
|
*LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n')
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
++LiteralEnd;
|
|
|
|
if (CurVariant == -1 || CurVariant == AsmPrinterVariant)
|
|
|
|
O.write(LastEmitted, LiteralEnd-LastEmitted);
|
|
|
|
LastEmitted = LiteralEnd;
|
|
|
|
break;
|
|
|
|
}
|
2006-05-05 21:47:05 +00:00
|
|
|
case '\n':
|
|
|
|
++LastEmitted; // Consume newline character.
|
|
|
|
O << "\n\t"; // Indent code with newline.
|
|
|
|
break;
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
case '$': {
|
|
|
|
++LastEmitted; // Consume '$' character.
|
2006-10-03 23:27:09 +00:00
|
|
|
bool Done = true;
|
|
|
|
|
|
|
|
// Handle escapes.
|
|
|
|
switch (*LastEmitted) {
|
|
|
|
default: Done = false; break;
|
|
|
|
case '$': // $$ -> $
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
if (CurVariant == -1 || CurVariant == AsmPrinterVariant)
|
|
|
|
O << '$';
|
|
|
|
++LastEmitted; // Consume second '$' character.
|
|
|
|
break;
|
2006-10-03 23:27:09 +00:00
|
|
|
case '(': // $( -> same as GCC's { character.
|
|
|
|
++LastEmitted; // Consume '(' character.
|
|
|
|
if (CurVariant != -1) {
|
|
|
|
std::cerr << "Nested variants found in inline asm string: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
CurVariant = 0; // We're in the first variant now.
|
|
|
|
break;
|
|
|
|
case '|':
|
|
|
|
++LastEmitted; // consume '|' character.
|
|
|
|
if (CurVariant == -1) {
|
|
|
|
std::cerr << "Found '|' character outside of variant in inline asm "
|
|
|
|
<< "string: '" << AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
++CurVariant; // We're in the next variant.
|
|
|
|
break;
|
|
|
|
case ')': // $) -> same as GCC's } char.
|
|
|
|
++LastEmitted; // consume ')' character.
|
|
|
|
if (CurVariant == -1) {
|
|
|
|
std::cerr << "Found '}' character outside of variant in inline asm "
|
|
|
|
<< "string: '" << AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
CurVariant = -1;
|
|
|
|
break;
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
}
|
2006-10-03 23:27:09 +00:00
|
|
|
if (Done) break;
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
|
|
|
|
bool HasCurlyBraces = false;
|
|
|
|
if (*LastEmitted == '{') { // ${variable}
|
|
|
|
++LastEmitted; // Consume '{' character.
|
|
|
|
HasCurlyBraces = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *IDStart = LastEmitted;
|
|
|
|
char *IDEnd;
|
|
|
|
long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs.
|
|
|
|
if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) {
|
|
|
|
std::cerr << "Bad $ operand number in inline asm string: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
LastEmitted = IDEnd;
|
|
|
|
|
2006-02-06 22:17:23 +00:00
|
|
|
char Modifier[2] = { 0, 0 };
|
|
|
|
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
if (HasCurlyBraces) {
|
2006-02-06 22:17:23 +00:00
|
|
|
// If we have curly braces, check for a modifier character. This
|
|
|
|
// supports syntax like ${0:u}, which correspond to "%u0" in GCC asm.
|
|
|
|
if (*LastEmitted == ':') {
|
|
|
|
++LastEmitted; // Consume ':' character.
|
|
|
|
if (*LastEmitted == 0) {
|
|
|
|
std::cerr << "Bad ${:} expression in inline asm string: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
Modifier[0] = *LastEmitted;
|
|
|
|
++LastEmitted; // Consume modifier character.
|
|
|
|
}
|
|
|
|
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
if (*LastEmitted != '}') {
|
|
|
|
std::cerr << "Bad ${} expression in inline asm string: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
++LastEmitted; // Consume '}' character.
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((unsigned)Val >= NumOperands-1) {
|
|
|
|
std::cerr << "Invalid $ operand number in inline asm string: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2006-02-23 19:21:04 +00:00
|
|
|
// Okay, we finally have a value number. Ask the target to print this
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
// operand!
|
2006-02-23 19:21:04 +00:00
|
|
|
if (CurVariant == -1 || CurVariant == AsmPrinterVariant) {
|
|
|
|
unsigned OpNo = 1;
|
2006-06-08 18:00:47 +00:00
|
|
|
|
|
|
|
bool Error = false;
|
|
|
|
|
2006-02-23 19:21:04 +00:00
|
|
|
// Scan to find the machine operand number for the operand.
|
2006-02-24 19:50:58 +00:00
|
|
|
for (; Val; --Val) {
|
2006-06-08 18:00:47 +00:00
|
|
|
if (OpNo >= MI->getNumOperands()) break;
|
2006-02-24 19:50:58 +00:00
|
|
|
unsigned OpFlags = MI->getOperand(OpNo).getImmedValue();
|
|
|
|
OpNo += (OpFlags >> 3) + 1;
|
|
|
|
}
|
2006-06-08 18:00:47 +00:00
|
|
|
|
|
|
|
if (OpNo >= MI->getNumOperands()) {
|
|
|
|
Error = true;
|
2006-02-24 20:21:58 +00:00
|
|
|
} else {
|
2006-06-08 18:00:47 +00:00
|
|
|
unsigned OpFlags = MI->getOperand(OpNo).getImmedValue();
|
|
|
|
++OpNo; // Skip over the ID number.
|
|
|
|
|
|
|
|
AsmPrinter *AP = const_cast<AsmPrinter*>(this);
|
|
|
|
if ((OpFlags & 7) == 4 /*ADDR MODE*/) {
|
|
|
|
Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant,
|
|
|
|
Modifier[0] ? Modifier : 0);
|
|
|
|
} else {
|
|
|
|
Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant,
|
|
|
|
Modifier[0] ? Modifier : 0);
|
|
|
|
}
|
2006-02-24 20:21:58 +00:00
|
|
|
}
|
|
|
|
if (Error) {
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
std::cerr << "Invalid operand found in inline asm: '"
|
|
|
|
<< AsmStr << "'\n";
|
|
|
|
MI->dump();
|
|
|
|
exit(1);
|
|
|
|
}
|
2006-02-23 19:21:04 +00:00
|
|
|
}
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-09-06 18:34:40 +00:00
|
|
|
O << "\n\t" << TAI->getInlineAsmEnd() << "\n";
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// PrintAsmOperand - Print the specified operand of MI, an INLINEASM
|
|
|
|
/// instruction, using the specified assembler variant. Targets should
|
|
|
|
/// overried this to format as appropriate.
|
|
|
|
bool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
|
2006-02-06 22:17:23 +00:00
|
|
|
unsigned AsmVariant, const char *ExtraCode) {
|
Implement smart printing of inline asm strings, handling variants and
substituted operands. For this testcase:
int %test(int %A, int %B) {
%C = call int asm "xyz $0, $1, $2", "=r,r,r"(int %A, int %B)
ret int %C
}
we now emit:
_test:
or r2, r3, r3
or r3, r4, r4
xyz r2, r2, r3 ;; look here
or r3, r2, r2
blr
... note the substituted operands. :)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25886 91177308-0d34-0410-b5e6-96231b3b80d8
2006-02-01 22:41:11 +00:00
|
|
|
// Target doesn't support this yet!
|
|
|
|
return true;
|
2006-01-27 02:10:10 +00:00
|
|
|
}
|
2006-02-24 20:21:58 +00:00
|
|
|
|
|
|
|
bool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
|
|
|
|
unsigned AsmVariant,
|
|
|
|
const char *ExtraCode) {
|
|
|
|
// Target doesn't support this yet!
|
|
|
|
return true;
|
|
|
|
}
|
2006-04-22 18:53:45 +00:00
|
|
|
|
|
|
|
/// printBasicBlockLabel - This method prints the label for the specified
|
|
|
|
/// MachineBasicBlock
|
2006-05-02 05:37:32 +00:00
|
|
|
void AsmPrinter::printBasicBlockLabel(const MachineBasicBlock *MBB,
|
|
|
|
bool printColon,
|
|
|
|
bool printComment) const {
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getPrivateGlobalPrefix() << "BB" << FunctionNumber << "_"
|
2006-05-02 17:36:46 +00:00
|
|
|
<< MBB->getNumber();
|
2006-05-02 05:37:32 +00:00
|
|
|
if (printColon)
|
|
|
|
O << ':';
|
2006-10-05 21:40:14 +00:00
|
|
|
if (printComment && MBB->getBasicBlock())
|
2006-09-06 18:34:40 +00:00
|
|
|
O << '\t' << TAI->getCommentString() << MBB->getBasicBlock()->getName();
|
2006-04-22 18:53:45 +00:00
|
|
|
}
|
2006-08-12 21:29:52 +00:00
|
|
|
|
|
|
|
/// printSetLabel - This method prints a set label for the specified
|
|
|
|
/// MachineBasicBlock
|
|
|
|
void AsmPrinter::printSetLabel(unsigned uid,
|
|
|
|
const MachineBasicBlock *MBB) const {
|
2006-09-06 18:34:40 +00:00
|
|
|
if (!TAI->getSetDirective())
|
2006-08-12 21:29:52 +00:00
|
|
|
return;
|
|
|
|
|
2006-09-06 18:34:40 +00:00
|
|
|
O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix()
|
|
|
|
<< getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ',';
|
2006-08-12 21:29:52 +00:00
|
|
|
printBasicBlockLabel(MBB, false, false);
|
2006-09-06 18:34:40 +00:00
|
|
|
O << '-' << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
|
2006-08-12 21:29:52 +00:00
|
|
|
<< '_' << uid << '\n';
|
|
|
|
}
|
2006-09-12 21:00:35 +00:00
|
|
|
|
|
|
|
/// printDataDirective - This method prints the asm directive for the
|
|
|
|
/// specified type.
|
|
|
|
void AsmPrinter::printDataDirective(const Type *type) {
|
|
|
|
const TargetData *TD = TM.getTargetData();
|
|
|
|
switch (type->getTypeID()) {
|
|
|
|
case Type::BoolTyID:
|
|
|
|
case Type::UByteTyID: case Type::SByteTyID:
|
|
|
|
O << TAI->getData8bitsDirective();
|
|
|
|
break;
|
|
|
|
case Type::UShortTyID: case Type::ShortTyID:
|
|
|
|
O << TAI->getData16bitsDirective();
|
|
|
|
break;
|
|
|
|
case Type::PointerTyID:
|
|
|
|
if (TD->getPointerSize() == 8) {
|
|
|
|
assert(TAI->getData64bitsDirective() &&
|
|
|
|
"Target cannot handle 64-bit pointer exprs!");
|
|
|
|
O << TAI->getData64bitsDirective();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
//Fall through for pointer size == int size
|
|
|
|
case Type::UIntTyID: case Type::IntTyID:
|
|
|
|
O << TAI->getData32bitsDirective();
|
|
|
|
break;
|
|
|
|
case Type::ULongTyID: case Type::LongTyID:
|
|
|
|
assert(TAI->getData64bitsDirective() &&
|
|
|
|
"Target cannot handle 64-bit constant exprs!");
|
|
|
|
O << TAI->getData64bitsDirective();
|
|
|
|
break;
|
|
|
|
case Type::FloatTyID: case Type::DoubleTyID:
|
|
|
|
assert (0 && "Should have already output floating point constant.");
|
|
|
|
default:
|
|
|
|
assert (0 && "Can't handle printing this type of thing");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|