bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

codegen_llvm: whitespace & formatting improvements

Browse source
This commit is contained in:
ljedrz 2018-10-08 16:52:34 +02:00
parent ef5c00d0ca
commit 61f47737b5
13 changed files with 69 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/librustc_codegen_llvm/abi.rs
View file

@ -150,7 +150,7 @@ impl LlvmType for CastTarget {
// Create list of fields in the main structure // Create list of fields in the main structure
let mut args: Vec<_> = let mut args: Vec<_> =
self.prefix.iter().flat_map(|option_kind| option_kind.map( self.prefix.iter().flat_map(|option_kind| option_kind.map(
|kind| Reg { kind: kind, size: self.prefix_chunk }.llvm_type(cx))) |kind| Reg { kind: kind, size: self.prefix_chunk }.llvm_type(cx)))
.chain((0..rest_count).map(|_| rest_ll_unit)) .chain((0..rest_count).map(|_| rest_ll_unit))
.collect(); .collect();
@ -259,8 +259,7 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
} }
pub trait FnTypeExt<'tcx> { pub trait FnTypeExt<'tcx> {
fn of_instance(cx: &CodegenCx<'ll, 'tcx>, instance: &ty::Instance<'tcx>) fn of_instance(cx: &CodegenCx<'ll, 'tcx>, instance: &ty::Instance<'tcx>) -> Self;
-> Self;
fn new(cx: &CodegenCx<'ll, 'tcx>, fn new(cx: &CodegenCx<'ll, 'tcx>,
sig: ty::FnSig<'tcx>, sig: ty::FnSig<'tcx>,
extra_args: &[Ty<'tcx>]) -> Self; extra_args: &[Ty<'tcx>]) -> Self;
@ -283,8 +282,7 @@ pub trait FnTypeExt<'tcx> {
} }
impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> { impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
fn of_instance(cx: &CodegenCx<'ll, 'tcx>, instance: &ty::Instance<'tcx>) fn of_instance(cx: &CodegenCx<'ll, 'tcx>, instance: &ty::Instance<'tcx>) -> Self {
-> Self {
let fn_ty = instance.ty(cx.tcx); let fn_ty = instance.ty(cx.tcx);
let sig = ty_fn_sig(cx, fn_ty); let sig = ty_fn_sig(cx, fn_ty);
let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig); let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
@ -292,16 +290,16 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
} }
fn new(cx: &CodegenCx<'ll, 'tcx>, fn new(cx: &CodegenCx<'ll, 'tcx>,
sig: ty::FnSig<'tcx>, sig: ty::FnSig<'tcx>,
extra_args: &[Ty<'tcx>]) -> Self { extra_args: &[Ty<'tcx>]) -> Self {
FnType::new_internal(cx, sig, extra_args, |ty, _| { FnType::new_internal(cx, sig, extra_args, |ty, _| {
ArgType::new(cx.layout_of(ty)) ArgType::new(cx.layout_of(ty))
}) })
} }
fn new_vtable(cx: &CodegenCx<'ll, 'tcx>, fn new_vtable(cx: &CodegenCx<'ll, 'tcx>,
sig: ty::FnSig<'tcx>, sig: ty::FnSig<'tcx>,
extra_args: &[Ty<'tcx>]) -> Self { extra_args: &[Ty<'tcx>]) -> Self {
FnType::new_internal(cx, sig, extra_args, |ty, arg_idx| { FnType::new_internal(cx, sig, extra_args, |ty, arg_idx| {
let mut layout = cx.layout_of(ty); let mut layout = cx.layout_of(ty);
// Don't pass the vtable, it's not an argument of the virtual fn. // Don't pass the vtable, it's not an argument of the virtual fn.

29
src/librustc_codegen_llvm/base.rs
View file

@ -213,8 +213,8 @@ pub fn unsized_info(
vtable_ptr.llvm_type(cx)) vtable_ptr.llvm_type(cx))
} }
_ => bug!("unsized_info: invalid unsizing {:?} -> {:?}", _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}",
source, source,
target), target),
} }
} }
@ -340,11 +340,11 @@ pub fn cast_shift_expr_rhs(
} }
fn cast_shift_rhs<'ll, F, G>(op: hir::BinOpKind, fn cast_shift_rhs<'ll, F, G>(op: hir::BinOpKind,
lhs: &'ll Value, lhs: &'ll Value,
rhs: &'ll Value, rhs: &'ll Value,
trunc: F, trunc: F,
zext: G) zext: G)
-> &'ll Value -> &'ll Value
where F: FnOnce(&'ll Value, &'ll Type) -> &'ll Value, where F: FnOnce(&'ll Value, &'ll Type) -> &'ll Value,
G: FnOnce(&'ll Value, &'ll Type) -> &'ll Value G: FnOnce(&'ll Value, &'ll Type) -> &'ll Value
{ {
@ -566,8 +566,8 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx) {
if declare::get_defined_value(cx, "main").is_some() { if declare::get_defined_value(cx, "main").is_some() {
// FIXME: We should be smart and show a better diagnostic here. // FIXME: We should be smart and show a better diagnostic here.
cx.sess().struct_span_err(sp, "entry symbol `main` defined multiple times") cx.sess().struct_span_err(sp, "entry symbol `main` defined multiple times")
.help("did you use #[no_mangle] on `fn main`? Use #[start] instead") .help("did you use #[no_mangle] on `fn main`? Use #[start] instead")
.emit(); .emit();
cx.sess().abort_if_errors(); cx.sess().abort_if_errors();
bug!(); bug!();
} }
@ -736,9 +736,9 @@ fn determine_cgu_reuse<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
} }
pub fn codegen_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, pub fn codegen_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
rx: mpsc::Receiver<Box<dyn Any + Send>>) rx: mpsc::Receiver<Box<dyn Any + Send>>)
-> OngoingCodegen { -> OngoingCodegen
{
check_for_rustc_errors_attr(tcx); check_for_rustc_errors_attr(tcx);
if let Some(true) = tcx.sess.opts.debugging_opts.thinlto { if let Some(true) = tcx.sess.opts.debugging_opts.thinlto {
@ -803,8 +803,7 @@ pub fn codegen_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// Run the monomorphization collector and partition the collected items into // Run the monomorphization collector and partition the collected items into
// codegen units. // codegen units.
let codegen_units = let codegen_units = tcx.collect_and_partition_mono_items(LOCAL_CRATE).1;
tcx.collect_and_partition_mono_items(LOCAL_CRATE).1;
let codegen_units = (*codegen_units).clone(); let codegen_units = (*codegen_units).clone();
// Force all codegen_unit queries so they are already either red or green // Force all codegen_unit queries so they are already either red or green
@ -988,7 +987,7 @@ fn collect_and_partition_mono_items<'a, 'tcx>(
if mode_string != "lazy" { if mode_string != "lazy" {
let message = format!("Unknown codegen-item collection mode '{}'. \ let message = format!("Unknown codegen-item collection mode '{}'. \
Falling back to 'lazy' mode.", Falling back to 'lazy' mode.",
mode_string); mode_string);
tcx.sess.warn(&message); tcx.sess.warn(&message);
} }

16
src/librustc_codegen_llvm/builder.rs
View file

@ -110,10 +110,10 @@ impl Builder<'a, 'll, 'tcx> {
} }
if self.cx.sess().count_llvm_insns() { if self.cx.sess().count_llvm_insns() {
*self.cx.stats *self.cx.stats
.borrow_mut() .borrow_mut()
.llvm_insns .llvm_insns
.entry(category.to_string()) .entry(category.to_string())
.or_insert(0) += 1; .or_insert(0) += 1;
} }
} }
@ -735,9 +735,9 @@ impl Builder<'a, 'll, 'tcx> {
} }
pub fn inline_asm_call(&self, asm: *const c_char, cons: *const c_char, pub fn inline_asm_call(&self, asm: *const c_char, cons: *const c_char,
inputs: &[&'ll Value], output: &'ll Type, inputs: &[&'ll Value], output: &'ll Type,
volatile: bool, alignstack: bool, volatile: bool, alignstack: bool,
dia: AsmDialect) -> Option<&'ll Value> { dia: AsmDialect) -> Option<&'ll Value> {
self.count_insn("inlineasm"); self.count_insn("inlineasm");
let volatile = if volatile { llvm::True } let volatile = if volatile { llvm::True }
@ -1093,7 +1093,7 @@ impl Builder<'a, 'll, 'tcx> {
) -> &'ll Value { ) -> &'ll Value {
unsafe { unsafe {
llvm::LLVMRustBuildAtomicCmpXchg(self.llbuilder, dst, cmp, src, llvm::LLVMRustBuildAtomicCmpXchg(self.llbuilder, dst, cmp, src,
order, failure_order, weak) order, failure_order, weak)
} }
} }
pub fn atomic_rmw( pub fn atomic_rmw(

2
src/librustc_codegen_llvm/consts.rs
View file

@ -124,7 +124,7 @@ pub fn get_static(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll Value {
assert!(!defined_in_current_codegen_unit, assert!(!defined_in_current_codegen_unit,
"consts::get_static() should always hit the cache for \ "consts::get_static() should always hit the cache for \
statics defined in the same CGU, but did not for `{:?}`", statics defined in the same CGU, but did not for `{:?}`",
def_id); def_id);
let ty = instance.ty(cx.tcx); let ty = instance.ty(cx.tcx);
let sym = cx.tcx.symbol_name(instance).as_str(); let sym = cx.tcx.symbol_name(instance).as_str();

14
src/librustc_codegen_llvm/context.rs
View file

@ -59,8 +59,8 @@ pub struct CodegenCx<'a, 'tcx: 'a> {
/// Cache instances of monomorphic and polymorphic items /// Cache instances of monomorphic and polymorphic items
pub instances: RefCell<FxHashMap<Instance<'tcx>, &'a Value>>, pub instances: RefCell<FxHashMap<Instance<'tcx>, &'a Value>>,
/// Cache generated vtables /// Cache generated vtables
pub vtables: RefCell<FxHashMap<(Ty<'tcx>, pub vtables: RefCell<FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>),
Option<ty::PolyExistentialTraitRef<'tcx>>), &'a Value>>, &'a Value>>,
/// Cache of constant strings, /// Cache of constant strings,
pub const_cstr_cache: RefCell<FxHashMap<LocalInternedString, &'a Value>>, pub const_cstr_cache: RefCell<FxHashMap<LocalInternedString, &'a Value>>,
@ -213,9 +213,9 @@ pub unsafe fn create_module(
impl<'a, 'tcx> CodegenCx<'a, 'tcx> { impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
crate fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
codegen_unit: Arc<CodegenUnit<'tcx>>, codegen_unit: Arc<CodegenUnit<'tcx>>,
llvm_module: &'a ::ModuleLlvm) llvm_module: &'a ::ModuleLlvm)
-> CodegenCx<'a, 'tcx> { -> CodegenCx<'a, 'tcx> {
// An interesting part of Windows which MSVC forces our hand on (and // An interesting part of Windows which MSVC forces our hand on (and
// apparently MinGW didn't) is the usage of `dllimport` and `dllexport` // apparently MinGW didn't) is the usage of `dllimport` and `dllexport`
// attributes in LLVM IR as well as native dependencies (in C these // attributes in LLVM IR as well as native dependencies (in C these
@ -270,8 +270,8 @@ impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
let dbg_cx = if tcx.sess.opts.debuginfo != DebugInfo::None { let dbg_cx = if tcx.sess.opts.debuginfo != DebugInfo::None {
let dctx = debuginfo::CrateDebugContext::new(llmod); let dctx = debuginfo::CrateDebugContext::new(llmod);
debuginfo::metadata::compile_unit_metadata(tcx, debuginfo::metadata::compile_unit_metadata(tcx,
&codegen_unit.name().as_str(), &codegen_unit.name().as_str(),
&dctx); &dctx);
Some(dctx) Some(dctx)
} else { } else {
None None

4
src/librustc_codegen_llvm/glue.rs
View file

@ -97,8 +97,8 @@ pub fn size_and_align_of_dst(bx: &Builder<'_, 'll, 'tcx>, t: Ty<'tcx>, info: Opt
C_usize(cx, std::cmp::max(sized_align, unsized_align) as u64) C_usize(cx, std::cmp::max(sized_align, unsized_align) as u64)
} }
_ => bx.select(bx.icmp(llvm::IntUGT, sized_align, unsized_align), _ => bx.select(bx.icmp(llvm::IntUGT, sized_align, unsized_align),
sized_align, sized_align,
unsized_align) unsized_align)
}; };
// Issue #27023: must add any necessary padding to `size` // Issue #27023: must add any necessary padding to `size`

46
src/librustc_codegen_llvm/intrinsic.rs
View file

@ -115,8 +115,8 @@ pub fn codegen_intrinsic_call(
let llval = match name { let llval = match name {
_ if simple.is_some() => { _ if simple.is_some() => {
bx.call(simple.unwrap(), bx.call(simple.unwrap(),
&args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
None) None)
} }
"unreachable" => { "unreachable" => {
return; return;
@ -373,7 +373,6 @@ pub fn codegen_intrinsic_call(
return; return;
} }
} }
}, },
"fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" => { "fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" => {
let sty = &arg_tys[0].sty; let sty = &arg_tys[0].sty;
@ -822,8 +821,7 @@ fn codegen_msvc_try(
let i64p = Type::i64(cx).ptr_to(); let i64p = Type::i64(cx).ptr_to();
let ptr_align = bx.tcx().data_layout.pointer_align; let ptr_align = bx.tcx().data_layout.pointer_align;
let slot = bx.alloca(i64p, "slot", ptr_align); let slot = bx.alloca(i64p, "slot", ptr_align);
bx.invoke(func, &[data], normal.llbb(), catchswitch.llbb(), bx.invoke(func, &[data], normal.llbb(), catchswitch.llbb(), None);
None);
normal.ret(C_i32(cx, 0)); normal.ret(C_i32(cx, 0));
@ -911,8 +909,7 @@ fn codegen_gnu_try(
// being thrown. The second value is a "selector" indicating which of // being thrown. The second value is a "selector" indicating which of
// the landing pad clauses the exception's type had been matched to. // the landing pad clauses the exception's type had been matched to.
// rust_try ignores the selector. // rust_try ignores the selector.
let lpad_ty = Type::struct_(cx, &[Type::i8p(cx), Type::i32(cx)], let lpad_ty = Type::struct_(cx, &[Type::i8p(cx), Type::i32(cx)], false);
false);
let vals = catch.landing_pad(lpad_ty, bx.cx.eh_personality(), 1); let vals = catch.landing_pad(lpad_ty, bx.cx.eh_personality(), 1);
catch.add_clause(vals, C_null(Type::i8p(cx))); catch.add_clause(vals, C_null(Type::i8p(cx)));
let ptr = catch.extract_value(vals, 0); let ptr = catch.extract_value(vals, 0);
@ -1000,11 +997,11 @@ fn generic_simd_intrinsic(
($msg: tt, $($fmt: tt)*) => { ($msg: tt, $($fmt: tt)*) => {
span_invalid_monomorphization_error( span_invalid_monomorphization_error(
bx.sess(), span, bx.sess(), span,
&format!(concat!("invalid monomorphization of `{}` intrinsic: ", &format!(concat!("invalid monomorphization of `{}` intrinsic: ", $msg),
$msg),
name, $($fmt)*)); name, $($fmt)*));
} }
} }
macro_rules! return_error { macro_rules! return_error {
($($fmt: tt)*) => { ($($fmt: tt)*) => {
{ {
@ -1021,14 +1018,13 @@ fn generic_simd_intrinsic(
} }
}; };
} }
macro_rules! require_simd { macro_rules! require_simd {
($ty: expr, $position: expr) => { ($ty: expr, $position: expr) => {
require!($ty.is_simd(), "expected SIMD {} type, found non-SIMD `{}`", $position, $ty) require!($ty.is_simd(), "expected SIMD {} type, found non-SIMD `{}`", $position, $ty)
} }
} }
let tcx = bx.tcx(); let tcx = bx.tcx();
let sig = tcx.normalize_erasing_late_bound_regions( let sig = tcx.normalize_erasing_late_bound_regions(
ty::ParamEnv::reveal_all(), ty::ParamEnv::reveal_all(),
@ -1121,8 +1117,8 @@ fn generic_simd_intrinsic(
}; };
return Ok(bx.shuffle_vector(args[0].immediate(), return Ok(bx.shuffle_vector(args[0].immediate(),
args[1].immediate(), args[1].immediate(),
C_vector(&indices))) C_vector(&indices)))
} }
if name == "simd_insert" { if name == "simd_insert" {
@ -1130,8 +1126,8 @@ fn generic_simd_intrinsic(
"expected inserted type `{}` (element of input `{}`), found `{}`", "expected inserted type `{}` (element of input `{}`), found `{}`",
in_elem, in_ty, arg_tys[2]); in_elem, in_ty, arg_tys[2]);
return Ok(bx.insert_element(args[0].immediate(), return Ok(bx.insert_element(args[0].immediate(),
args[2].immediate(), args[2].immediate(),
args[1].immediate())) args[1].immediate()))
} }
if name == "simd_extract" { if name == "simd_extract" {
require!(ret_ty == in_elem, require!(ret_ty == in_elem,
@ -1150,9 +1146,7 @@ fn generic_simd_intrinsic(
); );
match m_elem_ty.sty { match m_elem_ty.sty {
ty::Int(_) => {}, ty::Int(_) => {},
_ => { _ => return_error!("mask element type is `{}`, expected `i_`", m_elem_ty)
return_error!("mask element type is `{}`, expected `i_`", m_elem_ty);
}
} }
// truncate the mask to a vector of i1s // truncate the mask to a vector of i1s
let i1 = Type::i1(bx.cx); let i1 = Type::i1(bx.cx);
@ -1177,8 +1171,7 @@ fn generic_simd_intrinsic(
($msg: tt, $($fmt: tt)*) => { ($msg: tt, $($fmt: tt)*) => {
span_invalid_monomorphization_error( span_invalid_monomorphization_error(
bx.sess(), span, bx.sess(), span,
&format!(concat!("invalid monomorphization of `{}` intrinsic: ", &format!(concat!("invalid monomorphization of `{}` intrinsic: ", $msg),
$msg),
name, $($fmt)*)); name, $($fmt)*));
} }
} }
@ -1312,7 +1305,7 @@ fn generic_simd_intrinsic(
} }
if name == "simd_gather" { if name == "simd_gather" {
// simd_gather(values: <N x T>, pointers: <N x *_ T>, // simd_gather(values: <N x T>, pointers: <N x *_ T>,
// mask: <N x i{M}>) -> <N x T> // mask: <N x i{M}>) -> <N x T>
// * N: number of elements in the input vectors // * N: number of elements in the input vectors
@ -1360,7 +1353,7 @@ fn generic_simd_intrinsic(
// to the element type of the first argument // to the element type of the first argument
let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).sty { let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).sty {
ty::RawPtr(p) if p.ty == in_elem => (ptr_count(arg_tys[1].simd_type(tcx)), ty::RawPtr(p) if p.ty == in_elem => (ptr_count(arg_tys[1].simd_type(tcx)),
non_ptr(arg_tys[1].simd_type(tcx))), non_ptr(arg_tys[1].simd_type(tcx))),
_ => { _ => {
require!(false, "expected element type `{}` of second argument `{}` \ require!(false, "expected element type `{}` of second argument `{}` \
to be a pointer to the element type `{}` of the first \ to be a pointer to the element type `{}` of the first \
@ -1414,7 +1407,7 @@ fn generic_simd_intrinsic(
return Ok(v); return Ok(v);
} }
if name == "simd_scatter" { if name == "simd_scatter" {
// simd_scatter(values: <N x T>, pointers: <N x *mut T>, // simd_scatter(values: <N x T>, pointers: <N x *mut T>,
// mask: <N x i{M}>) -> () // mask: <N x i{M}>) -> ()
// * N: number of elements in the input vectors // * N: number of elements in the input vectors
@ -1570,7 +1563,6 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
) )
} }
} }
}; };
Ok(bx.$float_reduce(acc, args[0].immediate())) Ok(bx.$float_reduce(acc, args[0].immediate()))
} }
@ -1750,9 +1742,9 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
_ => {}, _ => {},
} }
require!(false, require!(false,
"unsupported operation on `{}` with element `{}`", "unsupported operation on `{}` with element `{}`",
in_ty, in_ty,
in_elem) in_elem)
})* })*
} }
} }

2
src/librustc_codegen_llvm/lib.rs
View file

@ -306,7 +306,7 @@ impl ModuleCodegen {
}; };
let bytecode_compressed = if emit_bc_compressed { let bytecode_compressed = if emit_bc_compressed {
Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name)) Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name))
.with_extension(RLIB_BYTECODE_EXTENSION)) .with_extension(RLIB_BYTECODE_EXTENSION))
} else { } else {
None None
}; };

2
src/librustc_codegen_llvm/metadata.rs
View file

@ -63,7 +63,7 @@ impl MetadataLoader for LlvmMetadataLoader {
let of = ObjectFile::new(mb) let of = ObjectFile::new(mb)
.map(|of| OwningRef::new(box of)) .map(|of| OwningRef::new(box of))
.ok_or_else(|| format!("provided path not an object file: '{}'", .ok_or_else(|| format!("provided path not an object file: '{}'",
filename.display()))?; filename.display()))?;
let buf = of.try_map(|of| search_meta_section(of, target, filename))?; let buf = of.try_map(|of| search_meta_section(of, target, filename))?;
Ok(rustc_erase_owner!(buf)) Ok(rustc_erase_owner!(buf))
} }

6
src/librustc_codegen_llvm/mir/analyze.rs
View file

@ -151,9 +151,9 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
} }
fn visit_place(&mut self, fn visit_place(&mut self,
place: &mir::Place<'tcx>, place: &mir::Place<'tcx>,
context: PlaceContext<'tcx>, context: PlaceContext<'tcx>,
location: Location) { location: Location) {
debug!("visit_place(place={:?}, context={:?})", place, context); debug!("visit_place(place={:?}, context={:?})", place, context);
let cx = self.fx.cx; let cx = self.fx.cx;

6
src/librustc_codegen_llvm/mir/block.rs
View file

@ -49,9 +49,9 @@ impl FunctionCx<'a, 'll, 'tcx> {
} }
fn codegen_terminator(&mut self, fn codegen_terminator(&mut self,
mut bx: Builder<'a, 'll, 'tcx>, mut bx: Builder<'a, 'll, 'tcx>,
bb: mir::BasicBlock, bb: mir::BasicBlock,
terminator: &mir::Terminator<'tcx>) terminator: &mir::Terminator<'tcx>)
{ {
debug!("codegen_terminator: {:?}", terminator); debug!("codegen_terminator: {:?}", terminator);

4
src/librustc_codegen_llvm/mono_item.rs
View file

@ -108,8 +108,8 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
match *self.as_mono_item() { match *self.as_mono_item() {
MonoItem::Fn(instance) => { MonoItem::Fn(instance) => {
format!("Fn({:?}, {})", format!("Fn({:?}, {})",
instance.def, instance.def,
instance.substs.as_ptr() as usize) instance.substs.as_ptr() as usize)
} }
MonoItem::Static(id) => { MonoItem::Static(id) => {
format!("Static({:?})", id) format!("Static({:?})", id)

2
src/librustc_codegen_llvm/type_of.rs
View file

@ -132,7 +132,7 @@ fn struct_llfields<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>,
debug!("struct_llfields: {}: {:?} offset: {:?} target_offset: {:?} \ debug!("struct_llfields: {}: {:?} offset: {:?} target_offset: {:?} \
effective_field_align: {}", effective_field_align: {}",
i, field, offset, target_offset, effective_field_align.abi()); i, field, offset, target_offset, effective_field_align.abi());
assert!(target_offset >= offset); assert!(target_offset >= offset);
let padding = target_offset - offset; let padding = target_offset - offset;
let padding_align = prev_effective_align.min(effective_field_align); let padding_align = prev_effective_align.min(effective_field_align);