[clang][DebugInfo] Emit debuginfo for non-constant case value

[yonghong-song]

Summary

Currently, clang does not emit debuginfo for the switch stmt
case value if it is an enum value. For example,

$ cat test.c
enum { AA = 1, BB = 2 };
int func1(int a) {
  switch(a) {
  case AA: return 10; 
  case BB: return 11; 
  default: break;
  }   
  return 0;
}
$ llvm-dwarfdump test.o | grep AA
$

Note that gcc does emit debuginfo for the same test case.

This patch added such a support with similar implementation
to CodeGenFunction::EmitDeclRefExprDbgValue(). With this patch,

$ clang -g -c test.c
$ llvm-dwarfdump test.o | grep AA
                DW_AT_name    ("AA")
$   

[dblaikie]

SGTM - could you also add some CHECKs in the test that show the enumeration was added to the enumerators list on the CU (& you can probably test with just one enumerator - don't need two in each test for instance)

& I'm not quite following - what's the difference between the two cases being tested? Oh, I guess the second has implicit conversions in the case parameters? Fair enough, maybe would benefit from some comments.

[yonghong-song]

In D134705#3818657, @dblaikie wrote:

SGTM - could you also add some CHECKs in the test that show the enumeration was added to the enumerators list on the CU (& you can probably test with just one enumerator - don't need two in each test for instance)

Okay, will do.

& I'm not quite following - what's the difference between the two cases being tested? Oh, I guess the second has implicit conversions in the case parameters? Fair enough, maybe would benefit from some comments.

Yes, the first is without implicit conversion and the second is with implicit conversion. I will add some comments to clarify it in the test.

[yonghong-song]

• simplify test case, add more CHECK's and add comments to explain the test.

clang/lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitCaseStmt(const CaseStmt &S,
   // Handle case ranges.
   if (S.getRHS()) {
     EmitCaseStmtRange(S, Attrs);
     return;
   }
 
   llvm::ConstantInt *CaseVal =
     Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
+
+  // Emit debuginfo for the case value if it is an enum value.
+  const ConstantExpr *CE;
+  if (auto ICE = dyn_cast<ImplicitCastExpr>(S.getLHS()))
+    CE = dyn_cast<ConstantExpr>(ICE->getSubExpr());
+  else
+    CE = dyn_cast<ConstantExpr>(S.getLHS());
+  if (CE) {
+    if (auto DE = dyn_cast<DeclRefExpr>(CE->getSubExpr()))
+      if (CGDebugInfo *Dbg = getDebugInfo())
+        if (CGM.getCodeGenOpts().hasReducedDebugInfo())
+          Dbg->EmitGlobalVariable(DE->getDecl(),
+              APValue(llvm::APSInt(CaseVal->getValue())));
+  }
+
   if (SwitchLikelihood)
     SwitchLikelihood->push_back(Stmt::getLikelihood(Attrs));
 
   // If the body of the case is just a 'break', try to not emit an empty block.
   // If we're profiling or we're not optimizing, leave the block in for better
   // debug and coverage analysis.
   if (!CGM.getCodeGenOpts().hasProfileClangInstr() &&
       CGM.getCodeGenOpts().OptimizationLevel > 0 &&

clang/test/CodeGen/debug-info-enum-case-val.c

+// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s
+
+enum { A = 1 };
+int func1(int a) {
+  switch(a) {
+  case A: return 10;
+  default: break;
+  }
+  return 0;
+}
+// CHECK:       !DICompositeType(tag: DW_TAG_enumeration_type
+// CHECK-SAME:  elements: [[TEST1_ENUMS:![0-9]*]]
+// CHECK:       [[TEST1_ENUMS]] = !{[[TEST1_E:![0-9]*]]}
+// CHECK:       [[TEST1_E]] = !DIEnumerator(name: "A", value: 1)
+
+// Test ImplicitCast of switch case enum value
+enum { B = 2 };
+typedef unsigned long long __t1;
+typedef __t1 __t2;
+int func2(__t2 a) {
+  switch(a) {
+  case B: return 10;
+  default: break;
+  }
+  return 0;
+}
+// CHECK:       !DICompositeType(tag: DW_TAG_enumeration_type
+// CHECK-SAME:  elements: [[TEST2_ENUMS:![0-9]*]]
+// CHECK:       [[TEST2_ENUMS]] = !{[[TEST2_E:![0-9]*]]}
+// CHECK:       [[TEST2_E]] = !DIEnumerator(name: "B", value: 2)