2004-08-17 01:15:22 +02: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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
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
}
llvm-svn: 24616
2005-12-06 07:18:55 +01:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2004-08-17 01:15:22 +02:00
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
|
|
|
#include "llvm/Constants.h"
|
2005-11-10 19:36:17 +01:00
|
|
|
#include "llvm/Module.h"
|
2005-11-21 09:25:09 +01:00
|
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
2004-08-17 01:15:22 +02:00
|
|
|
#include "llvm/Support/Mangler.h"
|
2005-08-17 21:34:49 +02:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2004-08-17 01:15:22 +02:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2005-12-28 07:29:02 +01:00
|
|
|
#include <iostream>
|
2004-08-17 01:15:22 +02:00
|
|
|
using namespace llvm;
|
|
|
|
|
2005-12-13 07:32:10 +01:00
|
|
|
AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm)
|
|
|
|
: FunctionNumber(0), O(o), TM(tm),
|
|
|
|
CommentString("#"),
|
|
|
|
GlobalPrefix(""),
|
|
|
|
PrivateGlobalPrefix("."),
|
|
|
|
GlobalVarAddrPrefix(""),
|
|
|
|
GlobalVarAddrSuffix(""),
|
|
|
|
FunctionAddrPrefix(""),
|
|
|
|
FunctionAddrSuffix(""),
|
|
|
|
ZeroDirective("\t.zero\t"),
|
|
|
|
AsciiDirective("\t.ascii\t"),
|
|
|
|
AscizDirective("\t.asciz\t"),
|
|
|
|
Data8bitsDirective("\t.byte\t"),
|
|
|
|
Data16bitsDirective("\t.short\t"),
|
|
|
|
Data32bitsDirective("\t.long\t"),
|
|
|
|
Data64bitsDirective("\t.quad\t"),
|
|
|
|
AlignDirective("\t.align\t"),
|
|
|
|
AlignmentIsInBytes(true),
|
|
|
|
SwitchToSectionDirective("\t.section\t"),
|
|
|
|
ConstantPoolSection("\t.section .rodata\n"),
|
|
|
|
StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"),
|
|
|
|
StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"),
|
|
|
|
LCOMMDirective(0),
|
|
|
|
COMMDirective("\t.comm\t"),
|
|
|
|
COMMDirectiveTakesAlignment(true),
|
|
|
|
HasDotTypeDotSizeDirective(true) {
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-11-21 08:06:27 +01:00
|
|
|
/// SwitchSection - Switch to the specified section of the executable if we
|
|
|
|
/// are not already in it!
|
|
|
|
///
|
|
|
|
void AsmPrinter::SwitchSection(const char *NewSection, const GlobalValue *GV) {
|
|
|
|
std::string NS;
|
|
|
|
|
|
|
|
if (GV && GV->hasSection())
|
2005-11-21 09:25:09 +01:00
|
|
|
NS = SwitchToSectionDirective + GV->getSection();
|
2005-11-21 08:06:27 +01:00
|
|
|
else
|
2005-12-09 20:28:49 +01:00
|
|
|
NS = std::string("\t")+NewSection;
|
2005-11-21 08:06:27 +01:00
|
|
|
|
|
|
|
if (CurrentSection != NS) {
|
|
|
|
CurrentSection = NS;
|
|
|
|
if (!CurrentSection.empty())
|
2005-12-09 20:28:49 +01:00
|
|
|
O << CurrentSection << '\n';
|
2005-11-21 08:06:27 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-17 01:15:22 +02:00
|
|
|
bool AsmPrinter::doInitialization(Module &M) {
|
2004-08-17 08:06:19 +02:00
|
|
|
Mang = new Mangler(M, GlobalPrefix);
|
2006-01-24 00:47:53 +01:00
|
|
|
|
2006-01-24 05:16:34 +01:00
|
|
|
if (!M.getModuleInlineAsm().empty())
|
|
|
|
O << CommentString << " Start of file scope inline assembly\n"
|
|
|
|
<< M.getModuleInlineAsm()
|
|
|
|
<< "\n" << CommentString << " End of file scope inline assembly\n";
|
2006-01-24 00:47:53 +01:00
|
|
|
|
2005-11-21 08:06:27 +01:00
|
|
|
SwitchSection("", 0); // Reset back to no section.
|
2004-08-17 01:15:22 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AsmPrinter::doFinalization(Module &M) {
|
|
|
|
delete Mang; Mang = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-11-21 08:51:36 +01:00
|
|
|
void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
|
2004-08-17 01:15:22 +02:00
|
|
|
// What's my mangled name?
|
2005-11-10 19:36:17 +01:00
|
|
|
CurrentFnName = Mang->getValueName(MF.getFunction());
|
2005-11-21 09:13:27 +01:00
|
|
|
IncrementFunctionNumber();
|
2004-08-17 01:15:22 +02:00
|
|
|
}
|
|
|
|
|
2005-11-21 09:25:09 +01: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) {
|
|
|
|
const std::vector<Constant*> &CP = MCP->getConstants();
|
|
|
|
if (CP.empty()) return;
|
|
|
|
const TargetData &TD = TM.getTargetData();
|
|
|
|
|
|
|
|
SwitchSection(ConstantPoolSection, 0);
|
|
|
|
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
|
|
|
|
// FIXME: force doubles to be naturally aligned. We should handle this
|
|
|
|
// more correctly in the future.
|
|
|
|
unsigned Alignment = TD.getTypeAlignmentShift(CP[i]->getType());
|
|
|
|
if (CP[i]->getType() == Type::DoubleTy && Alignment < 3) Alignment = 3;
|
|
|
|
|
|
|
|
EmitAlignment(Alignment);
|
|
|
|
O << PrivateGlobalPrefix << "CPI" << getFunctionNumber() << '_' << i
|
|
|
|
<< ":\t\t\t\t\t" << CommentString << *CP[i] << '\n';
|
|
|
|
EmitGlobalConstant(CP[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-13 07:32:10 +01: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) {
|
|
|
|
assert(GV->hasInitializer() && GV->hasAppendingLinkage() &&
|
|
|
|
"Not a special LLVM global!");
|
|
|
|
|
|
|
|
if (GV->getName() == "llvm.used")
|
|
|
|
return true; // No need to emit this at all.
|
|
|
|
|
2006-01-12 20:17:23 +01:00
|
|
|
if (GV->getName() == "llvm.global_ctors" && GV->use_empty()) {
|
2005-12-13 07:32:10 +01:00
|
|
|
SwitchSection(StaticCtorsSection, 0);
|
|
|
|
EmitAlignment(2, 0);
|
|
|
|
EmitXXStructorList(GV->getInitializer());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-01-12 20:17:23 +01:00
|
|
|
if (GV->getName() == "llvm.global_dtors" && GV->use_empty()) {
|
2005-12-13 07:32:10 +01:00
|
|
|
SwitchSection(StaticDtorsSection, 0);
|
|
|
|
EmitAlignment(2, 0);
|
|
|
|
EmitXXStructorList(GV->getInitializer());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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 02:17:37 +01:00
|
|
|
|
|
|
|
if (CS->getOperand(1)->isNullValue())
|
|
|
|
return; // Found a null terminator, exit printing.
|
|
|
|
// Emit the function pointer.
|
2005-12-13 07:32:10 +01:00
|
|
|
EmitGlobalConstant(CS->getOperand(1));
|
|
|
|
}
|
|
|
|
}
|
2005-11-21 09:25:09 +01:00
|
|
|
|
|
|
|
|
2005-11-21 08:51:36 +01:00
|
|
|
// EmitAlignment - Emit an alignment directive to the specified power of two.
|
|
|
|
void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const {
|
2005-11-14 20:00:06 +01:00
|
|
|
if (GV && GV->getAlignment())
|
|
|
|
NumBits = Log2_32(GV->getAlignment());
|
2005-11-10 19:09:27 +01:00
|
|
|
if (NumBits == 0) return; // No need to emit alignment.
|
2004-08-17 21:14:29 +02:00
|
|
|
if (AlignmentIsInBytes) NumBits = 1 << NumBits;
|
|
|
|
O << AlignDirective << NumBits << "\n";
|
|
|
|
}
|
|
|
|
|
2005-11-21 08:51:36 +01:00
|
|
|
/// EmitZeros - Emit a block of zeros.
|
2004-08-17 23:38:40 +02:00
|
|
|
///
|
2005-11-21 08:51:36 +01:00
|
|
|
void AsmPrinter::EmitZeros(uint64_t NumZeros) const {
|
2004-08-17 23:38:40 +02:00
|
|
|
if (NumZeros) {
|
|
|
|
if (ZeroDirective)
|
|
|
|
O << ZeroDirective << NumZeros << "\n";
|
|
|
|
else {
|
|
|
|
for (; NumZeros; --NumZeros)
|
|
|
|
O << Data8bitsDirective << "0\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-17 01:15:22 +02:00
|
|
|
// Print out the specified constant, without a storage class. Only the
|
|
|
|
// constants valid in constant expressions can occur here.
|
2005-11-21 08:51:36 +01:00
|
|
|
void AsmPrinter::EmitConstantValueOnly(const Constant *CV) {
|
2004-10-16 20:19:26 +02:00
|
|
|
if (CV->isNullValue() || isa<UndefValue>(CV))
|
2004-08-17 01:15:22 +02:00
|
|
|
O << "0";
|
|
|
|
else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
|
|
|
|
assert(CB == ConstantBool::True);
|
|
|
|
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 15:05:48 +02:00
|
|
|
O << (uint64_t)CI->getValue();
|
2004-08-17 01:15:22 +02:00
|
|
|
else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
|
|
|
|
O << CI->getValue();
|
2005-11-10 19:36:17 +01:00
|
|
|
else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
|
2005-04-02 14:21:51 +02: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 "" )
|
2005-11-10 19:36:17 +01:00
|
|
|
if (isa<Function>(GV))
|
|
|
|
O << FunctionAddrPrefix << Mang->getValueName(GV) << FunctionAddrSuffix;
|
2005-04-02 14:21:51 +02:00
|
|
|
else
|
2005-11-10 19:36:17 +01:00
|
|
|
O << GlobalVarAddrPrefix << Mang->getValueName(GV) << GlobalVarAddrSuffix;
|
2005-04-02 14:21:51 +02:00
|
|
|
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
|
2004-08-17 01:15:22 +02:00
|
|
|
const TargetData &TD = TM.getTargetData();
|
|
|
|
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());
|
2005-02-14 22:40:26 +01:00
|
|
|
if (int64_t Offset = TD.getIndexedOffset(ptrVal->getType(), idxVec)) {
|
|
|
|
if (Offset)
|
|
|
|
O << "(";
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(ptrVal);
|
2005-02-14 22:40:26 +01:00
|
|
|
if (Offset > 0)
|
|
|
|
O << ") + " << Offset;
|
|
|
|
else if (Offset < 0)
|
|
|
|
O << ") - " << -Offset;
|
2004-08-17 01:15:22 +02:00
|
|
|
} else {
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(ptrVal);
|
2004-08-17 01:15:22 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Instruction::Cast: {
|
|
|
|
// Support only non-converting or widening casts for now, that is, ones
|
|
|
|
// that do not involve a change in value. This assertion is really gross,
|
|
|
|
// and may not even be a complete check.
|
|
|
|
Constant *Op = CE->getOperand(0);
|
|
|
|
const Type *OpTy = Op->getType(), *Ty = CE->getType();
|
|
|
|
|
|
|
|
// Remember, kids, pointers can be losslessly converted back and forth
|
|
|
|
// into 32-bit or wider integers, regardless of signedness. :-P
|
|
|
|
assert(((isa<PointerType>(OpTy)
|
|
|
|
&& (Ty == Type::LongTy || Ty == Type::ULongTy
|
|
|
|
|| Ty == Type::IntTy || Ty == Type::UIntTy))
|
|
|
|
|| (isa<PointerType>(Ty)
|
|
|
|
&& (OpTy == Type::LongTy || OpTy == Type::ULongTy
|
|
|
|
|| OpTy == Type::IntTy || OpTy == Type::UIntTy))
|
|
|
|
|| (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
|
|
|
|
&& OpTy->isLosslesslyConvertibleTo(Ty))))
|
|
|
|
&& "FIXME: Don't yet support this kind of constant cast expr");
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(Op);
|
2004-08-17 01:15:22 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Instruction::Add:
|
|
|
|
O << "(";
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(CE->getOperand(0));
|
2004-08-17 01:15:22 +02:00
|
|
|
O << ") + (";
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(CE->getOperand(1));
|
2004-08-17 01:15:22 +02:00
|
|
|
O << ")";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0 && "Unsupported operator!");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
assert(0 && "Unknown constant value!");
|
|
|
|
}
|
|
|
|
}
|
2004-08-17 08:36:49 +02: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 19:06:33 +01:00
|
|
|
/// printAsCString - Print the specified array as a C compatible string, only if
|
2004-08-17 08:36:49 +02:00
|
|
|
/// the predicate isString is true.
|
|
|
|
///
|
2005-11-10 19:06:33 +01:00
|
|
|
static void printAsCString(std::ostream &O, const ConstantArray *CVA,
|
|
|
|
unsigned LastElt) {
|
2004-08-17 08:36:49 +02:00
|
|
|
assert(CVA->isString() && "Array is not string compatible!");
|
|
|
|
|
|
|
|
O << "\"";
|
2005-11-10 19:06:33 +01:00
|
|
|
for (unsigned i = 0; i != LastElt; ++i) {
|
2005-04-22 00:36:52 +02:00
|
|
|
unsigned char C =
|
2005-01-08 20:59:10 +01:00
|
|
|
(unsigned char)cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
|
2004-08-17 08:36:49 +02: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 << "\"";
|
|
|
|
}
|
|
|
|
|
2005-11-21 08:51:36 +01:00
|
|
|
/// EmitGlobalConstant - Print a general LLVM constant to the .s file.
|
2004-08-17 08:36:49 +02:00
|
|
|
///
|
2005-11-21 08:51:36 +01:00
|
|
|
void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
|
2004-08-17 08:36:49 +02:00
|
|
|
const TargetData &TD = TM.getTargetData();
|
|
|
|
|
2004-10-16 20:19:26 +02:00
|
|
|
if (CV->isNullValue() || isa<UndefValue>(CV)) {
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitZeros(TD.getTypeSize(CV->getType()));
|
2004-08-17 08:36:49 +02:00
|
|
|
return;
|
|
|
|
} else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
|
|
|
|
if (CVA->isString()) {
|
2005-11-10 19:06:33 +01:00
|
|
|
unsigned NumElts = CVA->getNumOperands();
|
|
|
|
if (AscizDirective && NumElts &&
|
|
|
|
cast<ConstantInt>(CVA->getOperand(NumElts-1))->getRawValue() == 0) {
|
|
|
|
O << AscizDirective;
|
|
|
|
printAsCString(O, CVA, NumElts-1);
|
|
|
|
} else {
|
|
|
|
O << AsciiDirective;
|
|
|
|
printAsCString(O, CVA, NumElts);
|
|
|
|
}
|
2004-08-17 08:36:49 +02:00
|
|
|
O << "\n";
|
|
|
|
} else { // Not a string. Print the values in successive locations
|
|
|
|
for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i)
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitGlobalConstant(CVA->getOperand(i));
|
2004-08-17 08:36:49 +02:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
|
|
|
|
// Print the fields in successive locations. Pad to align if needed!
|
|
|
|
const StructLayout *cvsLayout = TD.getStructLayout(CVS->getType());
|
2005-01-08 20:59:10 +01:00
|
|
|
uint64_t sizeSoFar = 0;
|
2004-08-17 08:36:49 +02: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.
|
2005-01-08 20:59:10 +01:00
|
|
|
uint64_t fieldSize = TD.getTypeSize(field->getType());
|
|
|
|
uint64_t padSize = ((i == e-1? cvsLayout->StructSize
|
2004-08-17 08:36:49 +02:00
|
|
|
: cvsLayout->MemberOffsets[i+1])
|
|
|
|
- cvsLayout->MemberOffsets[i]) - fieldSize;
|
|
|
|
sizeSoFar += fieldSize + padSize;
|
|
|
|
|
|
|
|
// Now print the actual field value
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitGlobalConstant(field);
|
2004-08-17 08:36:49 +02:00
|
|
|
|
|
|
|
// Insert the field padding unless it's zero bytes...
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitZeros(padSize);
|
2004-08-17 08:36:49 +02: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) {
|
2004-08-17 08:48:16 +02:00
|
|
|
if (Data64bitsDirective)
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data64bitsDirective << DoubleToBits(Val) << "\t" << CommentString
|
2004-08-17 23:38:40 +02:00
|
|
|
<< " double value: " << Val << "\n";
|
2004-08-17 08:48:16 +02:00
|
|
|
else if (TD.isBigEndian()) {
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " double most significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(DoubleToBits(Val))
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " double least significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2004-08-17 08:36:49 +02:00
|
|
|
} else {
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(DoubleToBits(Val))
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " double least significant word " << Val
|
2004-08-17 18:27:05 +02:00
|
|
|
<< "\n";
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " double most significant word " << Val
|
2004-08-17 18:27:05 +02:00
|
|
|
<< "\n";
|
2004-08-17 08:36:49 +02:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else {
|
2005-08-17 21:34:49 +02:00
|
|
|
O << Data32bitsDirective << FloatToBits(Val) << "\t" << CommentString
|
2004-08-17 18:27:05 +02:00
|
|
|
<< " float " << Val << "\n";
|
2004-08-17 08:36:49 +02: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-22 00:36:52 +02:00
|
|
|
|
2004-08-17 08:48:16 +02:00
|
|
|
if (Data64bitsDirective)
|
|
|
|
O << Data64bitsDirective << Val << "\n";
|
|
|
|
else if (TD.isBigEndian()) {
|
2004-08-17 08:36:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(Val >> 32)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " Double-word most significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2004-08-17 08:36:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(Val)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " Double-word least significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2004-08-17 08:36:49 +02:00
|
|
|
} else {
|
|
|
|
O << Data32bitsDirective << unsigned(Val)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " Double-word least significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2004-08-17 08:36:49 +02:00
|
|
|
O << Data32bitsDirective << unsigned(Val >> 32)
|
2004-08-18 04:22:55 +02:00
|
|
|
<< "\t" << CommentString << " Double-word most significant word "
|
2004-08-17 18:27:05 +02:00
|
|
|
<< Val << "\n";
|
2004-08-17 08:36:49 +02: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
}
llvm-svn: 24616
2005-12-06 07:18:55 +01: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 08:36:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const Type *type = CV->getType();
|
|
|
|
switch (type->getTypeID()) {
|
2005-04-22 00:36:52 +02:00
|
|
|
case Type::BoolTyID:
|
2004-08-17 08:36:49 +02:00
|
|
|
case Type::UByteTyID: case Type::SByteTyID:
|
|
|
|
O << Data8bitsDirective;
|
|
|
|
break;
|
|
|
|
case Type::UShortTyID: case Type::ShortTyID:
|
|
|
|
O << Data16bitsDirective;
|
|
|
|
break;
|
|
|
|
case Type::PointerTyID:
|
2005-02-04 14:47:16 +01:00
|
|
|
if (TD.getPointerSize() == 8) {
|
|
|
|
O << Data64bitsDirective;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
//Fall through for pointer size == int size
|
2004-08-17 08:36:49 +02:00
|
|
|
case Type::UIntTyID: case Type::IntTyID:
|
|
|
|
O << Data32bitsDirective;
|
|
|
|
break;
|
2005-04-22 00:36:52 +02:00
|
|
|
case Type::ULongTyID: case Type::LongTyID:
|
2005-08-08 06:26:32 +02:00
|
|
|
assert(Data64bitsDirective &&"Target cannot handle 64-bit constant exprs!");
|
|
|
|
O << Data64bitsDirective;
|
|
|
|
break;
|
2004-08-17 08:36:49 +02:00
|
|
|
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;
|
|
|
|
}
|
2005-11-21 08:51:36 +01:00
|
|
|
EmitConstantValueOnly(CV);
|
2004-08-17 08:36:49 +02:00
|
|
|
O << "\n";
|
|
|
|
}
|