// make sure that we only output it in exponential format if we can parse
// the value back and get the same value.
//
+ bool ignored;
bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble;
double Val = isDouble ? CFP->getValueAPF().convertToDouble() :
CFP->getValueAPF().convertToFloat();
}
}
// Otherwise we could not reparse it to exactly the same value, so we must
- // output the string in hexadecimal format!
+ // output the string in hexadecimal format! Note that loading and storing
+ // floating point types changes the bits of NaNs on some hosts, notably
+ // x86, so we must not use these types.
assert(sizeof(double) == sizeof(uint64_t) &&
"assuming that double is 64 bits!");
char Buffer[40];
- Out << "0x" << utohex_buffer(uint64_t(DoubleToBits(Val)), Buffer+40);
+ APFloat apf = CFP->getValueAPF();
+ // Floats are represented in ASCII IR as double, convert.
+ if (!isDouble)
+ apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
+ &ignored);
+ Out << "0x" <<
+ utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()),
+ Buffer+40);
return;
}
} else { // Cannot output in string format...
Out << '[';
if (CA->getNumOperands()) {
- Out << ' ';
printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CA->getOperand(0),
Out << ' ';
WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine);
}
- Out << ' ';
}
Out << ']';
}
const Type *ETy = CP->getType()->getElementType();
assert(CP->getNumOperands() > 0 &&
"Number of operands for a PackedConst must be > 0");
- Out << "< ";
+ Out << '<';
printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine);
Out << ' ';
WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine);
}
- Out << " >";
+ Out << '>';
return;
}
static void PrintLinkage(GlobalValue::LinkageTypes LT, raw_ostream &Out) {
switch (LT) {
+ case GlobalValue::PrivateLinkage: Out << "private "; break;
case GlobalValue::InternalLinkage: Out << "internal "; break;
case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
case GlobalValue::WeakLinkage: Out << "weak "; break;
PrintVisibility(GV->getVisibility(), Out);
if (GV->isThreadLocal()) Out << "thread_local ";
+ if (unsigned AddressSpace = GV->getType()->getAddressSpace())
+ Out << "addrspace(" << AddressSpace << ") ";
Out << (GV->isConstant() ? "constant " : "global ");
printType(GV->getType()->getElementType());
Out << ' ';
writeOperand(GV->getInitializer(), false);
}
-
- if (unsigned AddressSpace = GV->getType()->getAddressSpace())
- Out << " addrspace(" << AddressSpace << ") ";
if (GV->hasSection())
Out << ", section \"" << GV->getSection() << '"';
const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
// Special case conditional branches to swizzle the condition out to the front
- if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
+ if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
+ BranchInst &BI(cast<BranchInst>(I));
Out << ' ';
- writeOperand(I.getOperand(2), true);
+ writeOperand(BI.getCondition(), true);
Out << ", ";
- writeOperand(Operand, true);
+ writeOperand(BI.getSuccessor(0), true);
Out << ", ";
- writeOperand(I.getOperand(1), true);
+ writeOperand(BI.getSuccessor(1), true);
} else if (isa<SwitchInst>(I)) {
// Special case switch statement to get formatting nice and correct...
} else {
for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
Operand = I.getOperand(i);
- if (Operand->getType() != TheType) {
+ // note that Operand shouldn't be null, but the test helps make dump()
+ // more tolerant of malformed IR
+ if (Operand && Operand->getType() != TheType) {
PrintAllTypes = true; // We have differing types! Print them all!
break;
}