Support 128-bit enum variant in debuginfo codegen

compiler/rustc_codegen_gcc/src/common.rs

@@ -108,6 +108,10 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  self.const_uint(self.type_u64(), i)
  }
 
+ fn const_u128(&self, i: u128) -> RValue<'gcc> {
+ self.const_uint_big(self.type_u128(), i)
+ }
+
  fn const_usize(&self, i: u64) -> RValue<'gcc> {
  let bit_size = self.data_layout().pointer_size.bits();
  if bit_size < 64 {
@@ -254,7 +258,7 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  // SIMD builtins require a constant value.
  self.bitcast_if_needed(value, typ)
  }
- 
+
  fn const_ptr_byte_offset(&self, base_addr: Self::Value, offset: abi::Size) -> Self::Value {
  self.context.new_array_access(None, base_addr, self.const_usize(offset.bytes())).get_address(None)
  }

compiler/rustc_codegen_llvm/src/common.rs

@@ -168,6 +168,10 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  self.const_uint(self.type_i64(), i)
  }
 
+ fn const_u128(&self, i: u128) -> &'ll Value {
+ self.const_uint_big(self.type_i128(), i)
+ }
+
  fn const_usize(&self, i: u64) -> &'ll Value {
  let bit_size = self.data_layout().pointer_size.bits();
  if bit_size < 64 {

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -429,7 +429,7 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
  return existing_di_node;
  }
 
- debug!("type_di_node: {:?}", t);
+ debug!("type_di_node: {:?} kind: {:?}", t, t.kind());
 
  let DINodeCreationResult { di_node, already_stored_in_typemap } = match *t.kind() {
  ty::Never | ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => {

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs

@@ -412,13 +412,7 @@ fn build_enum_variant_member_di_node<'ll, 'tcx>(
  enum_type_and_layout.size.bits(),
  enum_type_and_layout.align.abi.bits() as u32,
  Size::ZERO.bits(),
- discr_value.opt_single_val().map(|value| {
- // NOTE(eddyb) do *NOT* remove this assert, until
- // we pass the full 128-bit value to LLVM, otherwise
- // truncation will be silent and remain undetected.
- assert_eq!(value as u64 as u128, value);
- cx.const_u64(value as u64)
- }),
+ discr_value.opt_single_val().map(|value| cx.const_u128(value)),
  DIFlags::FlagZero,
  variant_member_info.variant_struct_type_di_node,
  )

compiler/rustc_codegen_ssa/src/traits/consts.rs

@@ -15,6 +15,7 @@ pub trait ConstMethods<'tcx>: BackendTypes {
  fn const_i32(&self, i: i32) -> Self::Value;
  fn const_u32(&self, i: u32) -> Self::Value;
  fn const_u64(&self, i: u64) -> Self::Value;
+ fn const_u128(&self, i: u128) -> Self::Value;
  fn const_usize(&self, i: u64) -> Self::Value;
  fn const_u8(&self, i: u8) -> Self::Value;
  fn const_real(&self, t: Self::Type, val: f64) -> Self::Value;

tests/codegen/enum-debug-niche-2.rs

@@ -7,8 +7,8 @@
 // compile-flags: -g -C no-prepopulate-passes
 
 // CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}size: 32,{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Placeholder",{{.*}}extraData: i64 4294967295{{[,)].*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Error",{{.*}}extraData: i64 0{{[,)].*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Placeholder",{{.*}}extraData: i128 4294967295{{[,)].*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Error",{{.*}}extraData: i128 0{{[,)].*}}
 
 #![feature(never_type)]
 

tests/codegen/enum-u128.rs

@@ -0,0 +1,27 @@
+// This tests that debug info for "c-like" 128bit enums is properly emitted.
+// This is ignored for the fallback mode on MSVC due to problems with PDB.
+
+//
+// ignore-msvc
+
+// compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "Foo",{{.*}}flags: DIFlagEnumClass,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Lo",{{.*}}value: 0,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Hi",{{.*}}value: 18446744073709551616,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Bar",{{.*}}value: 18446745000000000123,{{.*}}
+
+#![allow(incomplete_features)]
+#![feature(repr128)]
+
+#[repr(u128)]
+pub enum Foo {
+ Lo,
+ Hi = 1 << 64,
+ Bar = 18_446_745_000_000_000_123,
+}
+
+pub fn main() {
+ let foo = Foo::Bar;
+}