Fix tests

Author: antoyo

src/asm.rs

@@ -537,9 +537,8 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
  }
  if dest.is_none() && options.contains(InlineAsmOptions::NORETURN) {
  let builtin_unreachable = self.context.get_builtin_function("__builtin_unreachable");
- let builtin_unreachable: RValue<'gcc> = unsafe {
- std::mem::transmute(builtin_unreachable)
- };
+ let builtin_unreachable: RValue<'gcc> =
+ unsafe { std::mem::transmute(builtin_unreachable) };
  self.call(self.type_void(), None, None, builtin_unreachable, &[], None, None);
  }
 

src/builder.rs

@@ -1004,7 +1004,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  }
  }
 
- let val = if let Some(_) = place.val.llextra {
+ let val = if place.val.llextra.is_some() {
  // FIXME: Merge with the `else` below?
  OperandValue::Ref(place.val)
  } else if place.layout.is_gcc_immediate() {
@@ -1672,7 +1672,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  _instance: Option<Instance<'tcx>>,
  ) -> RValue<'gcc> {
  // FIXME(antoyo): remove when having a proper API.
- let gcc_func = unsafe { std::mem::transmute(func) };
+ let gcc_func = unsafe { std::mem::transmute::<RValue<'gcc>, Function<'gcc>>(func) };
  let call = if self.functions.borrow().values().any(|value| *value == gcc_func) {
  self.function_call(func, args, funclet)
  } else {

src/context.rs

@@ -501,7 +501,7 @@ impl<'gcc, 'tcx> MiscMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  "rust_eh_personality"
  };
  let func = self.declare_func(name, self.type_i32(), &[], true);
- unsafe { std::mem::transmute(func) }
+ unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) }
  }
  };
  // TODO(antoyo): apply target cpu attributes.

src/int.rs

@@ -83,14 +83,16 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
  } else {
  let a_size = a_type.get_size();
  let b_size = b_type.get_size();
- if a_size > b_size {
- let b = self.context.new_cast(self.location, b, a_type);
- a >> b
- } else if a_size < b_size {
- let a = self.context.new_cast(self.location, a, b_type);
- a >> b
- } else {
- a >> b
+ match a_size.cmp(&b_size) {
+ std::cmp::Ordering::Less => {
+ let a = self.context.new_cast(self.location, a, b_type);
+ a >> b
+ }
+ std::cmp::Ordering::Equal => a >> b,
+ std::cmp::Ordering::Greater => {
+ let b = self.context.new_cast(self.location, b, a_type);
+ a >> b
+ }
  }
  }
  } else if a_type.is_vector() && a_type.is_vector() {
@@ -648,14 +650,16 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
  } else {
  let a_size = a_type.get_size();
  let b_size = b_type.get_size();
- if a_size > b_size {
- let b = self.context.new_cast(self.location, b, a_type);
- a << b
- } else if a_size < b_size {
- let a = self.context.new_cast(self.location, a, b_type);
- a << b
- } else {
- a << b
+ match a_size.cmp(&b_size) {
+ std::cmp::Ordering::Less => {
+ let a = self.context.new_cast(self.location, a, b_type);
+ a << b
+ }
+ std::cmp::Ordering::Equal => a << b,
+ std::cmp::Ordering::Greater => {
+ let b = self.context.new_cast(self.location, b, a_type);
+ a << b
+ }
  }
  }
  } else if a_type.is_vector() && a_type.is_vector() {

src/intrinsic/mod.rs

@@ -130,7 +130,9 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
  let llval = match name {
  _ if simple.is_some() => {
  // FIXME(antoyo): remove this cast when the API supports function.
- let func = unsafe { std::mem::transmute(simple.expect("simple")) };
+ let func = unsafe {
+ std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(simple.expect("simple"))
+ };
  self.call(
  self.type_void(),
  None,
@@ -675,7 +677,11 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
  let step3 = self.or(left, right);
 
  // Fourth step.
- if width == 8 { step3 } else { self.gcc_bswap(step3, width) }
+ if width == 8 {
+ step3
+ } else {
+ self.gcc_bswap(step3, width)
+ }
  }
  128 => {
  // TODO(antoyo): find a more efficient implementation?
@@ -1194,7 +1200,7 @@ fn codegen_gnu_try<'gcc>(
  bx.invoke(try_func_ty, None, None, try_func, &[data], then, catch, None, None);
  });
 
- let func = unsafe { std::mem::transmute(func) };
+ let func = unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) };
 
  // Note that no invoke is used here because by definition this function
  // can't panic (that's what it's catching).
@@ -1268,7 +1274,7 @@ fn gen_fn<'a, 'gcc, 'tcx>(
  // FIXME(eddyb) find a nicer way to do this.
  cx.linkage.set(FunctionType::Internal);
  let func = cx.declare_fn(name, fn_abi);
- let func_val = unsafe { std::mem::transmute(func) };
+ let func_val = unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) };
  cx.set_frame_pointer_type(func_val);
  cx.apply_target_cpu_attr(func_val);
  let block = Builder::append_block(cx, func_val, "entry-block");

src/intrinsic/simd.rs

@@ -13,6 +13,7 @@ use rustc_codegen_ssa::errors::InvalidMonomorphization;
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{BaseTypeMethods, BuilderMethods};
+#[cfg(feature = "master")]
 use rustc_hir as hir;
 use rustc_middle::mir::BinOp;
 use rustc_middle::span_bug;

src/lib.rs

@@ -413,7 +413,10 @@ impl WriteBackendMethods for GccCodegenBackend {
  back::write::codegen(cgcx, dcx, module, config)
  }
 
- fn prepare_thin(_module: ModuleCodegen<Self::Module>, _emit_summary: bool) -> (String, Self::ThinBuffer) {
+ fn prepare_thin(
+ _module: ModuleCodegen<Self::Module>,
+ _emit_summary: bool,
+ ) -> (String, Self::ThinBuffer) {
  unimplemented!();
  }
 

src/mono_item.rs

@@ -81,6 +81,6 @@ impl<'gcc, 'tcx> PreDefineMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  // TODO(antoyo): use inline attribute from there in linkage.set() above.
 
  self.functions.borrow_mut().insert(symbol_name.to_string(), decl);
- self.function_instances.borrow_mut().insert(instance, unsafe { std::mem::transmute(decl) });
+ self.function_instances.borrow_mut().insert(instance, decl);
  }
 }

tests/run/array.rs

@@ -205,6 +205,17 @@ impl Sub for i16 {
  }
 }
 
+#[track_caller]
+#[lang = "panic_const_add_overflow"]
+pub fn panic_const_add_overflow() -> ! {
+ panic("attempt to add with overflow");
+}
+
+#[track_caller]
+#[lang = "panic_const_sub_overflow"]
+pub fn panic_const_sub_overflow() -> ! {
+ panic("attempt to subtract with overflow");
+}
 
 /*
  * Code

tests/run/assign.rs

@@ -120,6 +120,12 @@ impl Add for isize {
  }
 }
 
+#[track_caller]
+#[lang = "panic_const_add_overflow"]
+pub fn panic_const_add_overflow() -> ! {
+ panic("attempt to add with overflow");
+}
+
 /*
  * Code
  */