use util::ppaux::Repr;
use syntax::ast;
-use syntax::ast::Ident;
use syntax::ast_util;
use syntax::parse::token::InternedString;
use syntax::parse::token;
pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
- opt_label: Option<Ident>,
+ opt_label: Option<ast::Ident>,
exit: usize)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_break_cont");
pub fn trans_break<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
- label_opt: Option<Ident>)
+ label_opt: Option<ast::Ident>)
-> Block<'blk, 'tcx> {
return trans_break_cont(bcx, expr, label_opt, cleanup::EXIT_BREAK);
}
pub fn trans_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
- label_opt: Option<Ident>)
+ label_opt: Option<ast::Ident>)
-> Block<'blk, 'tcx> {
return trans_break_cont(bcx, expr, label_opt, cleanup::EXIT_LOOP);
}
let filename = C_str_slice(ccx, filename);
let line = C_u32(ccx, loc.line as u32);
let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false);
- let expr_file_line = consts::addr_of(ccx, expr_file_line_const,
- "panic_loc", call_info.id);
+ let expr_file_line = consts::addr_of(ccx, expr_file_line_const, "panic_loc");
let args = vec!(expr_file_line);
let did = langcall(bcx, Some(call_info.span), "", PanicFnLangItem);
let bcx = callee::trans_lang_call(bcx,
let filename = C_str_slice(ccx, filename);
let line = C_u32(ccx, loc.line as u32);
let file_line_const = C_struct(ccx, &[filename, line], false);
- let file_line = consts::addr_of(ccx, file_line_const,
- "panic_bounds_check_loc", call_info.id);
+ let file_line = consts::addr_of(ccx, file_line_const, "panic_bounds_check_loc");
let args = vec!(file_line, index, len);
let did = langcall(bcx, Some(call_info.span), "", PanicBoundsCheckFnLangItem);
let bcx = callee::trans_lang_call(bcx,
use metadata::csearch;
use middle::subst::{self, Substs};
use trans::{self, adt, machine, type_of};
- use trans::common::{self, NodeIdAndSpan, CrateContext, FunctionContext, Block,
- C_bytes, NormalizingClosureTyper};
+ use trans::common::{self, NodeIdAndSpan, CrateContext, FunctionContext, Block, C_bytes,
+ NormalizingClosureTyper};
+ use trans::declare;
use trans::_match::{BindingInfo, TrByCopy, TrByMove, TrByRef};
use trans::monomorphize;
use trans::type_::Type;
let var_item = cx.tcx().map.get(node_id);
- let (ident, span) = match var_item {
+ let (name, span) = match var_item {
ast_map::NodeItem(item) => {
match item.node {
- ast::ItemStatic(..) => (item.ident, item.span),
- ast::ItemConst(..) => (item.ident, item.span),
+ ast::ItemStatic(..) => (item.ident.name, item.span),
+ ast::ItemConst(..) => (item.ident.name, item.span),
_ => {
cx.sess()
.span_bug(item.span,
let variable_type = ty::node_id_to_type(cx.tcx(), node_id);
let type_metadata = type_metadata(cx, variable_type, span);
let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id));
- let var_name = token::get_ident(ident).to_string();
+ let var_name = token::get_name(name).to_string();
let linkage_name =
namespace_node.mangled_name_of_contained_item(&var_name[..]);
let var_scope = namespace_node.scope;
let scope_metadata = scope_metadata(bcx.fcx, node_id, span);
declare_local(bcx,
- var_ident.node,
+ var_ident.node.name,
datum.ty,
scope_metadata,
DirectVariable { alloca: datum.val },
let ast_item = cx.tcx().map.find(node_id);
- let variable_ident = match ast_item {
+ let variable_name = match ast_item {
None => {
cx.sess().span_bug(span, "debuginfo::create_captured_var_metadata: node not found");
}
Some(ast_map::NodeLocal(pat)) | Some(ast_map::NodeArg(pat)) => {
match pat.node {
ast::PatIdent(_, ref path1, _) => {
- path1.node
+ path1.node.name
}
_ => {
cx.sess()
};
declare_local(bcx,
- variable_ident,
+ variable_name,
variable_type,
scope_metadata,
variable_access,
///
/// Adds the created metadata nodes directly to the crate's IR.
pub fn create_match_binding_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- variable_ident: ast::Ident,
+ variable_name: ast::Name,
binding: BindingInfo<'tcx>) {
if bcx.unreachable.get() ||
fn_should_be_ignored(bcx.fcx) ||
};
declare_local(bcx,
- variable_ident,
+ variable_name,
binding.ty,
scope_metadata,
var_access,
};
declare_local(bcx,
- var_ident.node,
+ var_ident.node.name,
datum.ty,
scope_metadata,
DirectVariable { alloca: datum.val },
let fnitem = cx.tcx().map.get(fn_ast_id);
- let (ident, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
+ let (name, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
ast_map::NodeItem(ref item) => {
if contains_nodebug_attribute(&item.attrs) {
return FunctionDebugContext::FunctionWithoutDebugInfo;
match item.node {
ast::ItemFn(ref fn_decl, _, _, ref generics, ref top_level_block) => {
- (item.ident, fn_decl, generics, top_level_block, item.span, true)
+ (item.ident.name, fn_decl, generics, top_level_block, item.span, true)
}
_ => {
cx.sess().span_bug(item.span,
return FunctionDebugContext::FunctionWithoutDebugInfo;
}
- (impl_item.ident,
+ (impl_item.ident.name,
&sig.decl,
&sig.generics,
body,
match expr.node {
ast::ExprClosure(_, ref fn_decl, ref top_level_block) => {
let name = format!("fn{}", token::gensym("fn"));
- let name = token::str_to_ident(&name[..]);
+ let name = token::intern(&name[..]);
(name, fn_decl,
// This is not quite right. It should actually inherit
// the generics of the enclosing function.
return FunctionDebugContext::FunctionWithoutDebugInfo;
}
- (trait_item.ident,
+ (trait_item.ident.name,
&sig.decl,
&sig.generics,
body,
// Get_template_parameters() will append a `<...>` clause to the function
// name if necessary.
- let mut function_name = String::from_str(&token::get_ident(ident));
+ let mut function_name = String::from_str(&token::get_name(name));
let template_parameters = get_template_parameters(cx,
generics,
param_substs,
actual_self_type,
codemap::DUMMY_SP);
- let ident = special_idents::type_self;
+ let name = token::get_name(special_idents::type_self.name);
- let ident = token::get_ident(ident);
- let name = CString::new(ident.as_bytes()).unwrap();
+ let name = CString::new(name.as_bytes()).unwrap();
let param_metadata = unsafe {
llvm::LLVMDIBuilderCreateTemplateTypeParameter(
DIB(cx),
}
fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
- variable_ident: ast::Ident,
+ variable_name: ast::Name,
variable_type: Ty<'tcx>,
scope_metadata: DIScope,
variable_access: VariableAccess,
let filename = span_start(cx, span).file.name.clone();
let file_metadata = file_metadata(cx, &filename[..]);
- let name = token::get_ident(variable_ident);
+ let name = token::get_name(variable_name);
let loc = span_start(cx, span);
let type_metadata = type_metadata(cx, variable_type, span);
// MemberDescription of the struct's single field.
let sole_struct_member_description = MemberDescription {
name: match non_null_variant.arg_names {
- Some(ref names) => token::get_ident(names[0]).to_string(),
+ Some(ref names) => token::get_name(names[0]).to_string(),
None => "".to_string()
},
llvm_type: non_null_llvm_type,
let mut arg_names: Vec<_> = match variant_info.arg_names {
Some(ref names) => {
names.iter()
- .map(|ident| {
- token::get_ident(*ident).to_string()
- }).collect()
+ .map(|&name| token::get_name(name).to_string())
+ .collect()
}
None => variant_info.args.iter().map(|_| "".to_string()).collect()
};
struct ScopeStackEntry {
scope_metadata: DIScope,
- ident: Option<ast::Ident>
+ name: Option<ast::Name>
}
- let mut scope_stack = vec!(ScopeStackEntry { scope_metadata: fn_metadata,
- ident: None });
+ let mut scope_stack = vec!(ScopeStackEntry { scope_metadata: fn_metadata, name: None });
scope_map.insert(fn_ast_id, fn_metadata);
// Push argument identifiers onto the stack so arguments integrate nicely
for arg in args {
pat_util::pat_bindings(def_map, &*arg.pat, |_, node_id, _, path1| {
scope_stack.push(ScopeStackEntry { scope_metadata: fn_metadata,
- ident: Some(path1.node) });
+ name: Some(path1.node.name) });
scope_map.insert(node_id, fn_metadata);
})
}
loc.col.to_usize() as c_uint)
};
- scope_stack.push(ScopeStackEntry { scope_metadata: scope_metadata,
- ident: None });
+ scope_stack.push(ScopeStackEntry { scope_metadata: scope_metadata, name: None });
inner_walk(cx, scope_stack, scope_map);
// pop artificial scopes
- while scope_stack.last().unwrap().ident.is_some() {
+ while scope_stack.last().unwrap().name.is_some() {
scope_stack.pop();
}
// scope stack and maybe introduce an artificial scope
if pat_util::pat_is_binding(def_map, &*pat) {
- let ident = path1.node;
+ let name = path1.node.name;
// LLVM does not properly generate 'DW_AT_start_scope' fields
// for variable DIEs. For this reason we have to introduce
// variables with the same name will cause the problem.
let need_new_scope = scope_stack
.iter()
- .any(|entry| entry.ident.iter().any(|i| i.name == ident.name));
+ .any(|entry| entry.name == Some(name));
if need_new_scope {
// Create a new lexical scope and push it onto the stack
scope_stack.push(ScopeStackEntry {
scope_metadata: scope_metadata,
- ident: Some(ident)
+ name: Some(name)
});
} else {
let prev_metadata = scope_stack.last().unwrap().scope_metadata;
scope_stack.push(ScopeStackEntry {
scope_metadata: prev_metadata,
- ident: Some(ident)
+ name: Some(name)
});
}
}
ty::with_path(cx.tcx(), def_id, |path| {
// prepend crate name if not already present
let krate = if def_id.krate == ast::LOCAL_CRATE {
- let crate_namespace_ident = token::str_to_ident(crate_root_namespace(cx));
- Some(ast_map::PathMod(crate_namespace_ident.name))
+ let crate_namespace_name = token::intern(crate_root_namespace(cx));
+ Some(ast_map::PathMod(crate_namespace_name))
} else {
None
};
/// section.
fn get_or_insert_gdb_debug_scripts_section_global(ccx: &CrateContext)
-> llvm::ValueRef {
- let section_var_name = b"__rustc_debug_gdb_scripts_section__\0";
+ let section_var_name = "__rustc_debug_gdb_scripts_section__";
let section_var = unsafe {
llvm::LLVMGetNamedGlobal(ccx.llmod(),
unsafe {
let llvm_type = Type::array(&Type::i8(ccx),
section_contents.len() as u64);
- let section_var = llvm::LLVMAddGlobal(ccx.llmod(),
- llvm_type.to_ref(),
- section_var_name.as_ptr()
- as *const _);
+
+ let section_var = declare::define_global(ccx, section_var_name,
+ llvm_type).unwrap_or_else(||{
+ ccx.sess().bug(&format!("symbol `{}` is already defined", section_var_name))
+ });
llvm::LLVMSetSection(section_var, section_name.as_ptr() as *const _);
llvm::LLVMSetInitializer(section_var, C_bytes(ccx, section_contents));
llvm::LLVMSetGlobalConstant(section_var, llvm::True);
projects / rust.git / commitdiff