use crate::ty::TyCtxt;
use rustc_ast as ast;
-use rustc_ast::expand::allocator::AllocatorKind;
-use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{self, MetadataRef};
-use rustc_hir::def::DefKind;
-use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc_hir::def_id::{CrateNum, DefId, StableCrateId, LOCAL_CRATE};
use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
use rustc_macros::HashStable;
use rustc_session::search_paths::PathKind;
use rustc_session::utils::NativeLibKind;
-use rustc_session::CrateDisambiguator;
+use rustc_span::hygiene::{ExpnHash, ExpnId};
use rustc_span::symbol::Symbol;
use rustc_span::Span;
use rustc_target::spec::Target;
}
}
-#[derive(PartialEq, Clone, Debug, Encodable, Decodable)]
-pub enum LibSource {
- Some(PathBuf),
- MetadataOnly,
- None,
-}
-
-impl LibSource {
- pub fn is_some(&self) -> bool {
- matches!(self, LibSource::Some(_))
- }
-
- pub fn option(&self) -> Option<PathBuf> {
- match *self {
- LibSource::Some(ref p) => Some(p.clone()),
- LibSource::MetadataOnly | LibSource::None => None,
- }
- }
-}
-
#[derive(Copy, Debug, PartialEq, Clone, Encodable, Decodable, HashStable)]
pub enum LinkagePreference {
RequireDynamic,
RequireStatic,
}
-#[derive(Clone, Debug, Encodable, Decodable, HashStable)]
+#[derive(Debug, Encodable, Decodable, HashStable)]
pub struct NativeLib {
pub kind: NativeLibKind,
pub name: Option<Symbol>,
pub struct DllImport {
pub name: Symbol,
pub ordinal: Option<u16>,
+ /// Calling convention for the function.
+ ///
+ /// On x86_64, this is always `DllCallingConvention::C`; on i686, it can be any
+ /// of the values, and we use `DllCallingConvention::C` to represent `"cdecl"`.
+ pub calling_convention: DllCallingConvention,
+ /// Span of import's "extern" declaration; used for diagnostics.
+ pub span: Span,
+}
+
+/// Calling convention for a function defined in an external library.
+///
+/// The usize value, where present, indicates the size of the function's argument list
+/// in bytes.
+#[derive(Clone, PartialEq, Debug, Encodable, Decodable, HashStable)]
+pub enum DllCallingConvention {
+ C,
+ Stdcall(usize),
+ Fastcall(usize),
+ Vectorcall(usize),
}
#[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
/// that it's *not* tracked for dependency information throughout compilation
/// (it'd break incremental compilation) and should only be called pre-HIR (e.g.
/// during resolve)
-pub trait CrateStore {
+pub trait CrateStore: std::fmt::Debug {
fn as_any(&self) -> &dyn Any;
- // resolve
+ // Foreign definitions.
+ // This information is safe to access, since it's hashed as part of the DefPathHash, which incr.
+ // comp. uses to identify a DefId.
fn def_key(&self, def: DefId) -> DefKey;
- fn def_kind(&self, def: DefId) -> DefKind;
fn def_path(&self, def: DefId) -> DefPath;
fn def_path_hash(&self, def: DefId) -> DefPathHash;
+
+ // This information is safe to access, since it's hashed as part of the StableCrateId, which
+ // incr. comp. uses to identify a CrateNum.
+ fn crate_name(&self, cnum: CrateNum) -> Symbol;
+ fn stable_crate_id(&self, cnum: CrateNum) -> StableCrateId;
+
+ /// Fetch a DefId from a DefPathHash for a foreign crate.
fn def_path_hash_to_def_id(
&self,
cnum: CrateNum,
index_guess: u32,
hash: DefPathHash,
) -> Option<DefId>;
-
- // "queries" used in resolve that aren't tracked for incremental compilation
- fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol;
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator;
- fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh;
-
- // This is basically a 1-based range of ints, which is a little
- // silly - I may fix that.
- fn crates_untracked(&self) -> Vec<CrateNum>;
+ fn expn_hash_to_expn_id(&self, cnum: CrateNum, index_guess: u32, hash: ExpnHash) -> ExpnId;
// utility functions
fn encode_metadata(&self, tcx: TyCtxt<'_>) -> EncodedMetadata;
- fn allocator_kind(&self) -> Option<AllocatorKind>;
}
pub type CrateStoreDyn = dyn CrateStore + sync::Sync;
-
-// This method is used when generating the command line to pass through to
-// system linker. The linker expects undefined symbols on the left of the
-// command line to be defined in libraries on the right, not the other way
-// around. For more info, see some comments in the add_used_library function
-// below.
-//
-// In order to get this left-to-right dependency ordering, we perform a
-// topological sort of all crates putting the leaves at the right-most
-// positions.
-pub fn used_crates(tcx: TyCtxt<'_>, prefer: LinkagePreference) -> Vec<(CrateNum, LibSource)> {
- let mut libs = tcx
- .crates()
- .iter()
- .cloned()
- .filter_map(|cnum| {
- if tcx.dep_kind(cnum).macros_only() {
- return None;
- }
- let source = tcx.used_crate_source(cnum);
- let path = match prefer {
- LinkagePreference::RequireDynamic => source.dylib.clone().map(|p| p.0),
- LinkagePreference::RequireStatic => source.rlib.clone().map(|p| p.0),
- };
- let path = match path {
- Some(p) => LibSource::Some(p),
- None => {
- if source.rmeta.is_some() {
- LibSource::MetadataOnly
- } else {
- LibSource::None
- }
- }
- };
- Some((cnum, path))
- })
- .collect::<Vec<_>>();
- let mut ordering = tcx.postorder_cnums(()).to_owned();
- ordering.reverse();
- libs.sort_by_cached_key(|&(a, _)| ordering.iter().position(|x| *x == a));
- libs
-}
projects / rustc.git / blobdiff