let ident = path.idents.last();
let name: &str = cx.sess.str_of(*ident);
let mdnode = do as_c_str(name) |name| { unsafe {
- llvm::LLVMDIBuilderCreateLocalVariable(DIB(cx),
- ArgVariableTag as u32, context, name,
- filemd, loc.line as c_uint, tymd, false, 0, 0)
+ llvm::LLVMDIBuilderCreateLocalVariable(
+ DIB(cx),
+ ArgVariableTag as u32,
+ context,
+ name,
+ filemd,
+ loc.line as c_uint,
+ tymd,
+ false,
+ 0,
+ 0)
// XXX need to pass in a real argument number
}};
let ret_ty_md = if cx.sess.opts.extra_debuginfo {
match ret_ty.node {
ast::ty_nil => ptr::null(),
- _ => create_ty(cx, ty::node_id_to_type(cx.tcx, id),
- ret_ty.span)
+ _ => create_ty(cx, ty::node_id_to_type(cx.tcx, id), ret_ty.span)
}
} else {
ptr::null()
};
let fn_ty = unsafe {
- llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx),
- file_md, create_DIArray(DIB(cx), [ret_ty_md]))
+ llvm::LLVMDIBuilderCreateSubroutineType(
+ DIB(cx),
+ file_md,
+ create_DIArray(DIB(cx), [ret_ty_md]))
};
let fn_md =
llvm::LLVMDIBuilderCreateFunction(
DIB(cx),
file_md,
- name, linkage,
- file_md, loc.line as c_uint,
- fn_ty, false, true,
+ name,
+ linkage,
+ file_md,
+ loc.line as c_uint,
+ fn_ty,
+ false,
+ true,
loc.line as c_uint,
FlagPrototyped as c_uint,
cx.sess.opts.optimize != session::No,
- fcx.llfn, ptr::null(), ptr::null())
+ fcx.llfn,
+ ptr::null(),
+ ptr::null())
}}};
dbg_cx(cx).created_functions.insert(id, fn_md);
let (size, align) = size_and_align_of(cx, t);
let ty_md = do as_c_str(name) |name| { unsafe {
llvm::LLVMDIBuilderCreateBasicType(
- DIB(cx), name,
- size * 8 as u64, align * 8 as u64, encoding as c_uint)
+ DIB(cx),
+ name,
+ bytes_to_bits(size),
+ bytes_to_bits(align),
+ encoding as c_uint)
}};
// One could think that this call is not necessary, as the create_ty() function will insert the
let (size, align) = size_and_align_of(cx, t);
let name = ty_to_str(cx.tcx, t);
let ptr_md = do as_c_str(name) |name| { unsafe {
- llvm::LLVMDIBuilderCreatePointerType(DIB(cx),
- pointee, size * 8 as u64, align * 8 as u64, name)
+ llvm::LLVMDIBuilderCreatePointerType(
+ DIB(cx),
+ pointee,
+ bytes_to_bits(size),
+ bytes_to_bits(align),
+ name)
}};
return ptr_md;
}
debug!("StructContext(%s)::add_member: %s, size=%u, align=%u, offset=%u",
self.name, name, size, align, offset);
-
+
let mem_t = do as_c_str(name) |name| { unsafe {
llvm::LLVMDIBuilderCreateMemberType(
- self.builder,
+ self.builder,
+ self.file,
+ name,
self.file,
- name,
- self.file,
line as c_uint,
- (size * 8) as c_ulonglong,
- (align * 8) as c_ulonglong,
- (offset * 8) as c_ulonglong,
- 0,
+ bytes_to_bits(size),
+ bytes_to_bits(align),
+ bytes_to_bits(offset),
+ 0,
ty)
}};
self.members.push(mem_t);
// let repr = adt::represent_type(ccx, t);
// match *repr {
- // Univariant(*) =>
+ // Univariant(*) =>
// {
// let size_with_alignment = self.get_total_size_with_alignment();
-
+
// if st.size != size_with_alignment {
// ccx.sess.bug("StructContext(%s)::verify_against_struct_or_tuple_type: invalid type size. Expected = %u, actual = %u",
// st.size, size_with_alignment);
// st.align, self.align);
// }
// },
- // _ => ccx.sess.bug(fmt!("StructContext(%s)::verify_against_struct_or_tuple_type: called with invalid type %?",
+ // _ => ccx.sess.bug(fmt!("StructContext(%s)::verify_against_struct_or_tuple_type: called with invalid type %?",
// self.name, t))
// }
//}
let members_md = create_DIArray(self.builder, self.members);
// The size of the struct/tuple must be rounded to the next multiple of its alignment.
- // Otherwise gdb has trouble reading the struct correct when it is embedded into another
+ // Otherwise gdb has trouble reading the struct correctly when it is embedded into another
// data structure. This is also the value `sizeof` in C would give.
- let total_size_with_alignment = self.get_total_size_with_alignment();
+ let actual_total_size = self.get_total_size_with_alignment();
let struct_md =
do as_c_str(self.name) |name| { unsafe {
llvm::LLVMDIBuilderCreateStructType(
self.builder,
- self.file,
+ self.file,
name,
- self.file,
+ self.file,
self.line as c_uint,
- (total_size_with_alignment * 8) as c_ulonglong,
- (self.align * 8) as c_ulonglong,
+ bytes_to_bits(actual_total_size),
+ bytes_to_bits(self.align),
0,
ptr::null(),
- members_md,
- 0,
+ members_md,
+ 0,
ptr::null())
}};
return struct_md;
let size = sys::size_of::<ValueRef>();
let align = sys::min_align_of::<ValueRef>();
let vp = do as_c_str("*void") |name| { unsafe {
- llvm::LLVMDIBuilderCreatePointerType(DIB(cx), ptr::null(),
- size*8 as u64, align*8 as u64, name)
+ llvm::LLVMDIBuilderCreatePointerType(
+ DIB(cx),
+ ptr::null(),
+ bytes_to_bits(size),
+ bytes_to_bits(align),
+ name)
}};
return (vp, size, align);
}
let subscripts = create_DIArray(DIB(cx), [subrange]);
return unsafe {
- llvm::LLVMDIBuilderCreateArrayType(DIB(cx),
- size * len * 8 as u64, align * 8 as u64, elem_ty_md, subscripts)
+ llvm::LLVMDIBuilderCreateArrayType(
+ DIB(cx),
+ bytes_to_bits(size * len),
+ bytes_to_bits(align),
+ elem_ty_md,
+ subscripts)
};
}
let mut vec_scx = StructContext::new(cx, ty_to_str(cx.tcx, vec_t), file_md, 0);
let size_t_type = create_basic_type(cx, ty::mk_uint(), vec_ty_span);
- vec_scx.add_member("fill", 0, sys::size_of::<libc::size_t>(),
- sys::min_align_of::<libc::size_t>(), size_t_type);
- vec_scx.add_member("alloc", 0, sys::size_of::<libc::size_t>(),
- sys::min_align_of::<libc::size_t>(), size_t_type);
+
+ vec_scx.add_member(
+ "fill",
+ 0,
+ sys::size_of::<libc::size_t>(),
+ sys::min_align_of::<libc::size_t>(),
+ size_t_type);
+
+ vec_scx.add_member(
+ "alloc",
+ 0,
+ sys::size_of::<libc::size_t>(),
+ sys::min_align_of::<libc::size_t>(),
+ size_t_type);
+
let subrange = unsafe {
llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0_i64, 0_i64)
};
let subscripts = create_DIArray(DIB(cx), [subrange]);
let data_ptr = unsafe {
- llvm::LLVMDIBuilderCreateArrayType(DIB(cx),
- arr_size * 8 as u64, arr_align * 8 as u64, elem_ty_md, subscripts)
+ llvm::LLVMDIBuilderCreateArrayType(
+ DIB(cx),
+ bytes_to_bits(arr_size),
+ bytes_to_bits(arr_align),
+ elem_ty_md,
+ subscripts)
};
- vec_scx.add_member("data", 0, 0, // clang says the size should be 0
- sys::min_align_of::<u8>(), data_ptr);
+ vec_scx.add_member(
+ "data",
+ 0,
+ 0, // clang says the size should be 0
+ sys::min_align_of::<u8>(), data_ptr);
+
let vec_md = vec_scx.finalize();
let mut box_scx = StructContext::new(cx, fmt!("box<%s>", name), file_md, 0);
let int_t = ty::mk_int();
let refcount_type = create_basic_type(cx, int_t, vec_ty_span);
- box_scx.add_member("refcnt", 0, sys::size_of::<uint>(),
- sys::min_align_of::<uint>(), refcount_type);
+
+ box_scx.add_member(
+ "refcnt",
+ 0,
+ sys::size_of::<uint>(),
+ sys::min_align_of::<uint>(),
+ refcount_type);
+
let (vp, vpsize, vpalign) = voidptr(cx);
box_scx.add_member("tydesc", 0, vpsize, vpalign, vp);
box_scx.add_member("prev", 0, vpsize, vpalign, vp);
let mut scx = StructContext::new(cx, ty_to_str(cx.tcx, vec_t), file_md, 0);
let (_, ptr_size, ptr_align) = voidptr(cx);
scx.add_member("vec", 0, ptr_size, ptr_align, elem_ptr);
- scx.add_member("length", 0, sys::size_of::<uint>(),
- sys::min_align_of::<uint>(), uint_type);
+ scx.add_member("length", 0, sys::size_of::<uint>(), sys::min_align_of::<uint>(), uint_type);
return scx.finalize();
}
let members = ~[output_ptr_md, vp] + inputs_vals;
return unsafe {
- llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_md,
+ llvm::LLVMDIBuilderCreateSubroutineType(
+ DIB(cx),
+ file_md,
create_DIArray(DIB(cx), members))
};
}
let name = ty_to_str(cx.tcx, t);
let md = do as_c_str(fmt!("NYI<%s>", name)) |name| { unsafe {
llvm::LLVMDIBuilderCreateBasicType(
- DIB(cx), name,
- 0_u64, 8_u64, DW_ATE_unsigned as c_uint)
+ DIB(cx),
+ name,
+ 0_u64,
+ 8_u64,
+ DW_ATE_unsigned as c_uint)
}};
return md;
}
let elems = ~[C_i32(line as i32), C_i32(col as i32), scope, ptr::null()];
unsafe {
let dbg_loc = llvm::LLVMMDNodeInContext(
- dbg_cx(cx).llcontext, vec::raw::to_ptr(elems),
- elems.len() as libc::c_uint);
+ dbg_cx(cx).llcontext,
+ vec::raw::to_ptr(elems),
+ elems.len() as c_uint);
+
llvm::LLVMSetCurrentDebugLocation(cx.builder.B, dbg_loc);
}
}
/// Return codemap::Loc corresponding to the beginning of the span
fn span_start(cx: &CrateContext, span: span) -> codemap::Loc {
- return cx.sess.codemap.lookup_char_pos(span.lo);
+ cx.sess.codemap.lookup_char_pos(span.lo)
}
fn size_and_align_of(cx: @mut CrateContext, t: ty::t) -> (uint, uint) {
(machine::llsize_of_real(cx, llty), machine::llalign_of_min(cx, llty))
}
+fn bytes_to_bits(bytes: uint) -> c_ulonglong {
+ (bytes * 8) as c_ulonglong
+}
+
#[inline]
fn dbg_cx<'a>(cx: &'a mut CrateContext) -> &'a mut DebugContext {
cx.dbg_cx.get_mut_ref()
projects / rust.git / commitdiff