Zero-extend 1-bit constantInt operands of the DbgValue

Author: laxmansole

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -247,13 +247,6 @@ void DwarfCompileUnit::addLocationAttribute(
   DIELoc *Loc = nullptr;
   std::optional<unsigned> NVPTXAddressSpace;
   std::unique_ptr<DIEDwarfExpression> DwarfExpr;
-
-  // Check if this variable is of boolean type
-  bool isBoolean = false;
-  if (GV && GV->getType())
-    if (auto *BasicType = dyn_cast<DIBasicType>(GV->getType()))
-      isBoolean = BasicType->getEncoding() == dwarf::DW_ATE_boolean;
-
   for (const auto &GE : GlobalExprs) {
     const GlobalVariable *Global = GE.Var;
     const DIExpression *Expr = GE.Expr;
@@ -264,17 +257,11 @@ void DwarfCompileUnit::addLocationAttribute(
     // DW_AT_const_value(X).
     if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
       addToAccelTable = true;
-
-      // Determine the value to use, normalizing booleans to 0 or 1
-      int64_t valueToUse = Expr->getElement(1);
-      if (isBoolean)
-        valueToUse = valueToUse ? 1 : 0;
-
       addConstantValue(
           *VariableDIE,
           DIExpression::SignedOrUnsignedConstant::UnsignedConstant ==
               *Expr->isConstant(),
-          valueToUse);
+          Expr->getElement(1));
       break;
     }
 
@@ -835,22 +822,6 @@ void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
   }
   if (!DVal->isVariadic()) {
     const DbgValueLocEntry *Entry = DVal->getLocEntries().begin();
-
-    // Helper function to handle boolean constant values with type safety
-    auto addConstantValueWithBooleanNormalization =
-        [&](DIE &VariableDie, uint64_t intValue, const DIType *Type) {
-          if (auto *BasicType = dyn_cast_or_null<DIBasicType>(Type)) {
-            if (BasicType->getEncoding() == dwarf::DW_ATE_boolean) {
-              // Normalize boolean values: any non-zero becomes 1, zero stays 0
-              uint64_t normalizedBoolValue = (intValue) ? 1 : 0;
-              addConstantValue(VariableDie, normalizedBoolValue, Type);
-              return;
-            }
-          }
-          // For non-boolean types, use the original constant value
-          addConstantValue(VariableDie, intValue, Type);
-        };
-
     if (Entry->isLocation()) {
       addVariableAddress(DV, VariableDie, Entry->getLoc());
     } else if (Entry->isInt()) {
@@ -867,8 +838,7 @@ void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
           addUInt(VariableDie, dwarf::DW_AT_LLVM_tag_offset,
                   dwarf::DW_FORM_data1, *DwarfExpr.TagOffset);
       } else
-        addConstantValueWithBooleanNormalization(VariableDie, Entry->getInt(),
-                                                 DV.getType());
+        addConstantValue(VariableDie, Entry->getInt(), DV.getType());
     } else if (Entry->isConstantFP()) {
       addConstantFPValue(VariableDie, Entry->getConstantFP());
     } else if (Entry->isConstantInt()) {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -3110,8 +3110,10 @@ void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                             &AP](const DbgValueLocEntry &Entry,
                                  DIExpressionCursor &Cursor) -> bool {
     if (Entry.isInt()) {
-      if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
-                 BT->getEncoding() == dwarf::DW_ATE_signed_char))
+      if (BT && (BT->getEncoding() == dwarf::DW_ATE_boolean))
+        DwarfExpr.addBooleanConstant(Entry.getInt());
+      else if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
+                      BT->getEncoding() == dwarf::DW_ATE_signed_char))
         DwarfExpr.addSignedConstant(Entry.getInt());
       else
         DwarfExpr.addUnsignedConstant(Entry.getInt());

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

@@ -194,6 +194,15 @@ void DwarfExpression::addStackValue() {
     emitOp(dwarf::DW_OP_stack_value);
 }
 
+void DwarfExpression::addBooleanConstant(int64_t Value) {
+  assert(isImplicitLocation() || isUnknownLocation());
+  LocationKind = Implicit;
+  if (Value == 0)
+    emitOp(dwarf::DW_OP_lit0);
+  else
+    emitOp(dwarf::DW_OP_lit1);
+}
+
 void DwarfExpression::addSignedConstant(int64_t Value) {
   assert(isImplicitLocation() || isUnknownLocation());
   LocationKind = Implicit;

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

@@ -229,6 +229,9 @@ class DwarfExpression {
   /// This needs to be called last to commit any pending changes.
   void finalize();
 
+  /// Emit a boolean constant.
+  void addBooleanConstant(int64_t Value);
+
   /// Emit a signed constant.
   void addSignedConstant(int64_t Value);
 

llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

@@ -109,8 +109,10 @@ MachineInstrBuilder MachineIRBuilder::buildConstDbgValue(const Constant &C,
   if (auto *CI = dyn_cast<ConstantInt>(NumericConstant)) {
     if (CI->getBitWidth() > 64)
       MIB.addCImm(CI);
-    else
+    else if (CI->getBitWidth() == 1)
       MIB.addImm(CI->getZExtValue());
+    else
+      MIB.addImm(CI->getSExtValue());
   } else if (auto *CFP = dyn_cast<ConstantFP>(NumericConstant)) {
     MIB.addFPImm(CFP);
   } else if (isa<ConstantPointerNull>(NumericConstant)) {

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

@@ -733,6 +733,8 @@ MachineOperand GetMOForConstDbgOp(const SDDbgOperand &Op) {
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
     if (CI->getBitWidth() > 64)
       return MachineOperand::CreateCImm(CI);
+    if (CI->getBitWidth() == 1)
+      return MachineOperand::CreateImm(CI->getZExtValue());
     return MachineOperand::CreateImm(CI->getSExtValue());
   }
   if (const ConstantFP *CF = dyn_cast<ConstantFP>(V))

llvm/lib/Transforms/Utils/Local.cpp

@@ -3387,7 +3387,11 @@ DIExpression *llvm::getExpressionForConstant(DIBuilder &DIB, const Constant &C,
   // Create integer constant expression.
   auto createIntegerExpression = [&DIB](const Constant &CV) -> DIExpression * {
     const APInt &API = cast<ConstantInt>(&CV)->getValue();
-    std::optional<int64_t> InitIntOpt = API.trySExtValue();
+    std::optional<int64_t> InitIntOpt;
+    if (API.getBitWidth() == 1)
+      InitIntOpt = API.tryZExtValue();
+    else
+      InitIntOpt = API.trySExtValue();
     return InitIntOpt ? DIB.createConstantValueExpression(
                             static_cast<uint64_t>(*InitIntOpt))
                       : nullptr;

llvm/test/DebugInfo/debug-bool-const-value.ll

@@ -1,10 +1,6 @@
 ; REQUIRES: object-emission
 ; RUN: %llc_dwarf %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
-
-; CHECK: {{.*}}DW_TAG_variable
-; CHECK-NEXT: {{.*}} DW_AT_name      ("global_bool_const")
-; CHECK: {{.*}} DW_AT_const_value     (1)
 ; CHECK: {{.*}}DW_TAG_variable
 ; CHECK-NEXT: {{.*}} DW_AT_const_value     (1)
 ; CHECK-NEXT: {{.*}} DW_AT_name    ("arg")
@@ -20,9 +16,9 @@ declare void @"llvm.dbg.value"(metadata %".1", metadata %".2", metadata %".3")
 
 !llvm.dbg.cu = !{ !2 }
 !llvm.module.flags = !{ !9, !10 }
-!0 = !{ !11 }
+
 !1 = !DIFile(directory: "", filename: "test")
-!2 = distinct !DICompileUnit(emissionKind: FullDebug, file: !1, isOptimized: false, language: DW_LANG_C_plus_plus, runtimeVersion: 0, globals: !0)
+!2 = distinct !DICompileUnit(emissionKind: FullDebug, file: !1, isOptimized: false, language: DW_LANG_C_plus_plus, runtimeVersion: 0)
 !3 = !DIBasicType(encoding: DW_ATE_boolean, name: "bool", size: 8)
 !4 = !DISubroutineType(types: !{null})
 !5 = distinct !DISubprogram(file: !1, isDefinition: true, isLocal: false, isOptimized: false, line: 5, linkageName: "test", name: "test", scope: !1, scopeLine: 5, type: !4, unit: !2)
@@ -31,5 +27,3 @@ declare void @"llvm.dbg.value"(metadata %".1", metadata %".2", metadata %".3")
 !8 = !DIExpression()
 !9 = !{ i32 2, !"Dwarf Version", i32 4 }
 !10 = !{ i32 2, !"Debug Info Version", i32 3 }
-!11 = !DIGlobalVariableExpression(var: !12, expr: !DIExpression(DW_OP_consts, 18446744073709551615, DW_OP_stack_value))
-!12 = distinct !DIGlobalVariable(name: "global_bool_const", scope: !2, file: !1, line: 1, type: !3, isLocal: false, isDefinition: true)