129 lines
4.4 KiB
Rust
129 lines
4.4 KiB
Rust
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use context::SharedCrateContext;
|
|
use monomorphize::Instance;
|
|
use rustc::ty::TyCtxt;
|
|
use std::borrow::Cow;
|
|
use syntax::codemap::Span;
|
|
use trans_item::TransItem;
|
|
use util::nodemap::FnvHashMap;
|
|
|
|
// In the SymbolMap we collect the symbol names of all translation items of
|
|
// the current crate. This map exists as a performance optimization. Symbol
|
|
// names of translation items are deterministic and fully defined by the item.
|
|
// Thus they could also always be recomputed if needed.
|
|
|
|
pub struct SymbolMap<'tcx> {
|
|
index: FnvHashMap<TransItem<'tcx>, (usize, usize)>,
|
|
arena: String,
|
|
}
|
|
|
|
impl<'tcx> SymbolMap<'tcx> {
|
|
|
|
pub fn build<'a, I>(scx: &SharedCrateContext<'a, 'tcx>,
|
|
trans_items: I)
|
|
-> SymbolMap<'tcx>
|
|
where I: Iterator<Item=TransItem<'tcx>>
|
|
{
|
|
// Check for duplicate symbol names
|
|
let mut symbols: Vec<_> = trans_items.map(|trans_item| {
|
|
(trans_item, trans_item.compute_symbol_name(scx))
|
|
}).collect();
|
|
|
|
(&mut symbols[..]).sort_by(|&(_, ref sym1), &(_, ref sym2)|{
|
|
sym1.cmp(sym2)
|
|
});
|
|
|
|
for pair in (&symbols[..]).windows(2) {
|
|
let sym1 = &pair[0].1;
|
|
let sym2 = &pair[1].1;
|
|
|
|
if *sym1 == *sym2 {
|
|
let trans_item1 = pair[0].0;
|
|
let trans_item2 = pair[1].0;
|
|
|
|
let span1 = get_span(scx.tcx(), trans_item1);
|
|
let span2 = get_span(scx.tcx(), trans_item2);
|
|
|
|
// Deterministically select one of the spans for error reporting
|
|
let span = match (span1, span2) {
|
|
(Some(span1), Some(span2)) => {
|
|
Some(if span1.lo.0 > span2.lo.0 {
|
|
span1
|
|
} else {
|
|
span2
|
|
})
|
|
}
|
|
(Some(span), None) |
|
|
(None, Some(span)) => Some(span),
|
|
_ => None
|
|
};
|
|
|
|
let error_message = format!("symbol `{}` is already defined", sym1);
|
|
|
|
if let Some(span) = span {
|
|
scx.sess().span_fatal(span, &error_message)
|
|
} else {
|
|
scx.sess().fatal(&error_message)
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut symbol_map = SymbolMap {
|
|
index: FnvHashMap(),
|
|
arena: String::with_capacity(1024),
|
|
};
|
|
|
|
for (trans_item, symbol) in symbols {
|
|
let start_index = symbol_map.arena.len();
|
|
symbol_map.arena.push_str(&symbol[..]);
|
|
let end_index = symbol_map.arena.len();
|
|
let prev_entry = symbol_map.index.insert(trans_item,
|
|
(start_index, end_index));
|
|
if prev_entry.is_some() {
|
|
bug!("TransItem encountered twice?")
|
|
}
|
|
}
|
|
|
|
fn get_span<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|
trans_item: TransItem<'tcx>) -> Option<Span> {
|
|
match trans_item {
|
|
TransItem::Fn(Instance { def, .. }) => {
|
|
tcx.map.as_local_node_id(def)
|
|
}
|
|
TransItem::Static(node_id) => Some(node_id),
|
|
TransItem::DropGlue(_) => None,
|
|
}.map(|node_id| {
|
|
tcx.map.span(node_id)
|
|
})
|
|
}
|
|
|
|
symbol_map
|
|
}
|
|
|
|
pub fn get(&self, trans_item: TransItem<'tcx>) -> Option<&str> {
|
|
self.index.get(&trans_item).map(|&(start_index, end_index)| {
|
|
&self.arena[start_index .. end_index]
|
|
})
|
|
}
|
|
|
|
pub fn get_or_compute<'map, 'scx>(&'map self,
|
|
scx: &SharedCrateContext<'scx, 'tcx>,
|
|
trans_item: TransItem<'tcx>)
|
|
-> Cow<'map, str> {
|
|
if let Some(sym) = self.get(trans_item) {
|
|
Cow::from(sym)
|
|
} else {
|
|
Cow::from(trans_item.compute_symbol_name(scx))
|
|
}
|
|
}
|
|
}
|