addBlock(Die, Attribute, Loc);
}
-/// isTypeSigned - Return true if the type is signed.
-static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
- if (Ty.isDerivedType())
- return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
- SizeInBits);
- if (Ty.isBasicType())
- if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
- DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
- *SizeInBits = Ty.getSizeInBits();
- return true;
- }
- return false;
-}
-
/// Return true if type encoding is unsigned.
static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
DIDerivedType DTy(Ty);
return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
DIBasicType BTy(Ty);
- if (BTy.isBasicType()) {
- unsigned Encoding = BTy.getEncoding();
- if (Encoding == dwarf::DW_ATE_unsigned ||
- Encoding == dwarf::DW_ATE_unsigned_char ||
- Encoding == dwarf::DW_ATE_boolean)
- return true;
- }
- return false;
+ if (!BTy.isBasicType())
+ return false;
+ unsigned Encoding = BTy.getEncoding();
+ assert(Encoding == dwarf::DW_ATE_unsigned ||
+ Encoding == dwarf::DW_ATE_unsigned_char ||
+ Encoding == dwarf::DW_ATE_signed ||
+ Encoding == dwarf::DW_ATE_signed_char ||
+ Encoding == dwarf::DW_ATE_boolean && "Unsupported encoding");
+ return (Encoding == dwarf::DW_ATE_unsigned ||
+ Encoding == dwarf::DW_ATE_unsigned_char ||
+ Encoding == dwarf::DW_ATE_boolean);
}
/// If this type is derived from a base type then return base type size.
return BaseType.getSizeInBits();
}
-/// addConstantValue - Add constant value entry in variable DIE.
-void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
- DIType Ty) {
- // FIXME: This is a bit conservative/simple - it emits negative values at
- // their maximum bit width which is a bit unfortunate (& doesn't prefer
- // udata/sdata over dataN as suggested by the DWARF spec)
- assert(MO.isImm() && "Invalid machine operand!");
- int SizeInBits = -1;
- bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
- dwarf::Form Form;
-
- // If we're a signed constant definitely use sdata.
- if (SignedConstant) {
- addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
- return;
- }
-
- // Else use data for now unless it's larger than we can deal with.
- switch (SizeInBits) {
- case 8:
- Form = dwarf::DW_FORM_data1;
- break;
- case 16:
- Form = dwarf::DW_FORM_data2;
- break;
- case 32:
- Form = dwarf::DW_FORM_data4;
- break;
- case 64:
- Form = dwarf::DW_FORM_data8;
- break;
- default:
- Form = dwarf::DW_FORM_udata;
- addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
- return;
- }
- addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
-}
-
/// addConstantFPValue - Add constant value entry in variable DIE.
void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
assert(MO.isFPImm() && "Invalid machine operand!");
}
/// addConstantValue - Add constant value entry in variable DIE.
-void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
- bool Unsigned) {
- addConstantValue(Die, CI->getValue(), Unsigned);
+void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
+ addConstantValue(Die, CI->getValue(), Ty);
+}
+
+/// addConstantValue - Add constant value entry in variable DIE.
+void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
+ DIType Ty) {
+ assert(MO.isImm() && "Invalid machine operand!");
+
+ addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
+}
+
+void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
+ // FIXME: This is a bit conservative/simple - it emits negative values always
+ // sign extended to 64 bits rather than minimizing the number of bytes.
+ addUInt(Die, dwarf::DW_AT_const_value,
+ Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
+}
+
+void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
+ addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
}
// addConstantValue - Add constant value entry in variable DIE.
void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
unsigned CIBitWidth = Val.getBitWidth();
if (CIBitWidth <= 64) {
- // If we're a signed constant definitely use sdata.
- if (!Unsigned) {
- addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
- Val.getSExtValue());
- return;
- }
-
- // Else use data for now unless it's larger than we can deal with.
- dwarf::Form Form;
- switch (CIBitWidth) {
- case 8:
- Form = dwarf::DW_FORM_data1;
- break;
- case 16:
- Form = dwarf::DW_FORM_data2;
- break;
- case 32:
- Form = dwarf::DW_FORM_data4;
- break;
- case 64:
- Form = dwarf::DW_FORM_data8;
- break;
- default:
- addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
- Val.getZExtValue());
- return;
- }
- addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
+ addConstantValue(Die, Unsigned,
+ Unsigned ? Val.getZExtValue() : Val.getSExtValue());
return;
}
}
/// constructSubprogramArguments - Construct function argument DIEs.
-DIE *DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
- DIE *ObjectPointer = nullptr;
+void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
DIDescriptor Ty = Args.getElement(i);
if (Ty.isUnspecifiedParameter()) {
addType(Arg, DIType(Ty));
if (DIType(Ty).isArtificial())
addFlag(Arg, dwarf::DW_AT_artificial);
- if (DIType(Ty).isObjectPointer())
- ObjectPointer = &Arg;
}
}
- return ObjectPointer;
}
/// constructTypeDIE - Construct type DIE from DICompositeType.
addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
if (Value *Val = VP.getValue()) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
- addConstantValue(ParamDIE, CI,
- isUnsignedDIType(DD, resolve(VP.getType())));
+ addConstantValue(ParamDIE, CI, resolve(VP.getType()));
else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
// For declaration non-type template parameters (such as global values and
// functions)
// Add arguments. Do not add arguments for subprogram definition. They will
// be handled while processing variables.
- if (DIE *ObjectPointer = constructSubprogramArguments(SPDie, Args))
- addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, *ObjectPointer);
+ constructSubprogramArguments(SPDie, Args);
}
if (SP.isArtificial())
// emitting AT_const_value multiple times, we only add AT_const_value when
// it is not a static member.
if (!IsStaticMember)
- addConstantValue(*VariableDIE, CI, isUnsignedDIType(DD, GTy));
+ addConstantValue(*VariableDIE, CI, GTy);
} else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
addToAccelTable = true;
// GV is a merged global.
addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
else if (DVInsn->getOperand(0).isCImm())
addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
- isUnsignedDIType(DD, DV.getType()));
+ DV.getType());
return VariableDie;
}
dwarf::DW_ACCESS_public);
if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
- addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
+ addConstantValue(StaticMemberDIE, CI, Ty);
if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
addConstantFPValue(StaticMemberDIE, CFP);