OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Limit publicness to crate where possible and remove unused imports

Browse Source
This commit is contained in:
bjorn3 2020-03-27 12:14:45 +01:00
parent b113e88ddb
commit f288959c00
35 changed files with 223 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/abi/comments.rs
View File

@ -5,7 +5,7 @@ use rustc::mir;
use crate::abi::pass_mode::*;
use crate::prelude::*;
pub fn add_args_header_comment(fx: &mut FunctionCx<impl Backend>) {
pub(super) fn add_args_header_comment(fx: &mut FunctionCx<impl Backend>) {
fx.add_global_comment(format!(
"kind loc.idx param pass mode ty"
));
@ -49,14 +49,14 @@ pub(super) fn add_arg_comment<'tcx>(
));
}
pub fn add_locals_header_comment(fx: &mut FunctionCx<impl Backend>) {
pub(super) fn add_locals_header_comment(fx: &mut FunctionCx<impl Backend>) {
fx.add_global_comment(String::new());
fx.add_global_comment(format!(
"kind local ty size align (abi,pref)"
));
}
pub fn add_local_place_comments<'tcx>(
pub(super) fn add_local_place_comments<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
place: CPlace<'tcx>,
local: Local,

20
src/abi/mod.rs
View File

@ -10,10 +10,10 @@ use cranelift_codegen::ir::AbiParam;
use self::pass_mode::*;
use crate::prelude::*;
pub use self::returning::{can_return_to_ssa_var, codegen_return};
pub(crate) use self::returning::{can_return_to_ssa_var, codegen_return};
// Copied from https://github.com/rust-lang/rust/blob/c2f4c57296f0d929618baed0b0d6eb594abf01eb/src/librustc/ty/layout.rs#L2349
pub fn fn_sig_for_fn_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> ty::PolyFnSig<'tcx> {
pub(crate) fn fn_sig_for_fn_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> ty::PolyFnSig<'tcx> {
let ty = instance.monomorphic_ty(tcx);
match ty.kind {
ty::FnDef(..) |
@ -163,7 +163,7 @@ fn clif_sig_from_fn_sig<'tcx>(
}
}
pub fn get_function_name_and_sig<'tcx>(
pub(crate) fn get_function_name_and_sig<'tcx>(
tcx: TyCtxt<'tcx>,
triple: &target_lexicon::Triple,
inst: Instance<'tcx>,
@ -180,7 +180,7 @@ pub fn get_function_name_and_sig<'tcx>(
}
/// Instance must be monomorphized
pub fn import_function<'tcx>(
pub(crate) fn import_function<'tcx>(
tcx: TyCtxt<'tcx>,
module: &mut Module<impl Backend>,
inst: Instance<'tcx>,
@ -193,7 +193,7 @@ pub fn import_function<'tcx>(
impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
/// Instance must be monomorphized
pub fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
pub(crate) fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
let func_id = import_function(self.tcx, self.module, inst);
let func_ref = self
.module
@ -234,7 +234,7 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
results
}
pub fn easy_call(
pub(crate) fn easy_call(
&mut self,
name: &str,
args: &[CValue<'tcx>],
@ -288,7 +288,7 @@ fn local_place<'tcx>(
fx.local_map[&local]
}
pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_block: Block, should_codegen_locals: bool) {
pub(crate) fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_block: Block, should_codegen_locals: bool) {
let ssa_analyzed = crate::analyze::analyze(fx);
#[cfg(debug_assertions)]
@ -423,7 +423,7 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_block
.jump(*fx.block_map.get(START_BLOCK).unwrap(), &[]);
}
pub fn codegen_terminator_call<'tcx>(
pub(crate) fn codegen_terminator_call<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
span: Span,
func: &Operand<'tcx>,
@ -444,7 +444,7 @@ pub fn codegen_terminator_call<'tcx>(
ty::Instance::resolve(fx.tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap();
if fx.tcx.symbol_name(instance).name.as_str().starts_with("llvm.") {
crate::intrinsics::llvm::codegen_llvm_intrinsic_call(
crate::intrinsics::codegen_llvm_intrinsic_call(
fx,
&fx.tcx.symbol_name(instance).name.as_str(),
substs,
@ -640,7 +640,7 @@ fn codegen_call_inner<'tcx>(
}
}
pub fn codegen_drop<'tcx>(
pub(crate) fn codegen_drop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
span: Span,
drop_place: CPlace<'tcx>,

4
src/abi/pass_mode.rs
View File

@ -3,7 +3,7 @@ use crate::prelude::*;
pub(super) use EmptySinglePair::*;
#[derive(Copy, Clone, Debug)]
pub enum PassMode {
pub(super) enum PassMode {
NoPass,
ByVal(Type),
ByValPair(Type, Type),
@ -76,7 +76,7 @@ impl PassMode {
}
}
pub fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMode {
pub(super) fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMode {
if layout.is_zst() {
// WARNING zst arguments must never be passed, as that will break CastKind::ClosureFnPointer
PassMode::NoPass

4
src/abi/returning.rs
View File

@ -5,7 +5,7 @@ fn return_layout<'a, 'tcx>(fx: &mut FunctionCx<'a, 'tcx, impl Backend>) -> TyLay
fx.layout_of(fx.monomorphize(&fx.mir.local_decls[RETURN_PLACE].ty))
}
pub fn can_return_to_ssa_var<'tcx>(tcx: TyCtxt<'tcx>, dest_layout: TyLayout<'tcx>) -> bool {
pub(crate) fn can_return_to_ssa_var<'tcx>(tcx: TyCtxt<'tcx>, dest_layout: TyLayout<'tcx>) -> bool {
match get_pass_mode(tcx, dest_layout) {
PassMode::NoPass | PassMode::ByVal(_) => true,
// FIXME Make it possible to return ByValPair and ByRef to an ssa var.
@ -101,7 +101,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx, B: Backend, T>(
(call_inst, meta)
}
pub fn codegen_return(fx: &mut FunctionCx<impl Backend>) {
pub(crate) fn codegen_return(fx: &mut FunctionCx<impl Backend>) {
match get_pass_mode(fx.tcx, return_layout(fx)) {
PassMode::NoPass | PassMode::ByRef { sized: true } => {
fx.bcx.ins().return_(&[]);

2
src/allocator.rs
View File

@ -13,7 +13,7 @@ use crate::prelude::*;
use rustc_ast::expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
/// Returns whether an allocator shim was created
pub fn codegen(tcx: TyCtxt<'_>, module: &mut Module<impl Backend + 'static>) -> bool {
pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut Module<impl Backend + 'static>) -> bool {
let any_dynamic_crate = tcx.dependency_formats(LOCAL_CRATE).iter().any(|(_, list)| {
use rustc::middle::dependency_format::Linkage;
list.iter().any(|&linkage| linkage == Linkage::Dynamic)

4
src/analyze.rs
View File

@ -4,12 +4,12 @@ use rustc::mir::StatementKind::*;
use rustc_index::vec::IndexVec;
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum SsaKind {
pub(crate) enum SsaKind {
NotSsa,
Ssa,
}
pub fn analyze(fx: &FunctionCx<'_, '_, impl Backend>) -> IndexVec<Local, SsaKind> {
pub(crate) fn analyze(fx: &FunctionCx<'_, '_, impl Backend>) -> IndexVec<Local, SsaKind> {
let mut flag_map = fx.mir.local_decls.iter().map(|local_decl| {
if fx.clif_type(fx.monomorphize(&local_decl.ty)).is_some() {
SsaKind::Ssa

2
src/archive.rs
View File

@ -23,7 +23,7 @@ enum ArchiveEntry {
File(PathBuf),
}
pub struct ArArchiveBuilder<'a> {
pub(crate) struct ArArchiveBuilder<'a> {
config: ArchiveConfig<'a>,
src_archives: Vec<(PathBuf, ar::Archive<File>)>,
// Don't use `HashMap` here, as the order is important. `rust.metadata.bin` must always be at

6
src/atomic_shim.rs
View File

@ -8,7 +8,7 @@ use crate::prelude::*;
#[no_mangle]
pub static mut __cg_clif_global_atomic_mutex: libc::pthread_mutex_t = libc::PTHREAD_MUTEX_INITIALIZER;
pub fn init_global_lock(module: &mut Module<impl Backend>, bcx: &mut FunctionBuilder<'_>) {
pub(crate) fn init_global_lock(module: &mut Module<impl Backend>, bcx: &mut FunctionBuilder<'_>) {
if std::env::var("CG_CLIF_JIT").is_ok () {
// When using JIT, dylibs won't find the __cg_clif_global_atomic_mutex data object defined here,
// so instead define it in the cg_clif dylib.
@ -46,7 +46,7 @@ pub fn init_global_lock(module: &mut Module<impl Backend>, bcx: &mut FunctionBui
bcx.ins().call(pthread_mutex_init, &[atomic_mutex, nullptr]);
}
pub fn lock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) {
pub(crate) fn lock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) {
let atomic_mutex = fx.module.declare_data(
"__cg_clif_global_atomic_mutex",
Linkage::Import,
@ -71,7 +71,7 @@ pub fn lock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) {
fx.bcx.ins().call(pthread_mutex_lock, &[atomic_mutex]);
}
pub fn unlock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) {
pub(crate) fn unlock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) {
let atomic_mutex = fx.module.declare_data(
"__cg_clif_global_atomic_mutex",
Linkage::Import,

12
src/backend.rs
View File

@ -14,7 +14,7 @@ use gimli::SectionId;
use crate::debuginfo::{DebugReloc, DebugRelocName};
pub trait WriteMetadata {
pub(crate) trait WriteMetadata {
fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>, is_like_osx: bool);
}
@ -38,7 +38,7 @@ impl WriteMetadata for object::write::Object {
}
}
pub trait WriteDebugInfo {
pub(crate) trait WriteDebugInfo {
type SectionId;
fn add_debug_section(&mut self, name: SectionId, data: Vec<u8>) -> Self::SectionId;
@ -99,7 +99,7 @@ impl WriteDebugInfo for ObjectProduct {
}
}
pub trait Emit {
pub(crate) trait Emit {
fn emit(self) -> Vec<u8>;
}
@ -109,7 +109,7 @@ impl Emit for ObjectProduct {
}
}
pub fn with_object(sess: &Session, name: &str, f: impl FnOnce(&mut Object)) -> Vec<u8> {
pub(crate) fn with_object(sess: &Session, name: &str, f: impl FnOnce(&mut Object)) -> Vec<u8> {
let triple = crate::build_isa(sess, true).triple().clone();
let mut metadata_object =
object::write::Object::new(triple.binary_format, triple.architecture);
@ -118,9 +118,9 @@ pub fn with_object(sess: &Session, name: &str, f: impl FnOnce(&mut Object)) -> V
metadata_object.write().unwrap()
}
pub type Backend = impl cranelift_module::Backend<Product: Emit + WriteDebugInfo>;
pub(crate) type Backend = impl cranelift_module::Backend<Product: Emit + WriteDebugInfo>;
pub fn make_module(sess: &Session, name: String) -> Module<Backend> {
pub(crate) fn make_module(sess: &Session, name: String) -> Module<Backend> {
let module: Module<ObjectBackend> = Module::new(
ObjectBuilder::new(
crate::build_isa(sess, true),

8
src/base.rs
View File

@ -3,7 +3,7 @@ use rustc_index::vec::IndexVec;
use crate::prelude::*;
pub fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
pub(crate) fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
cx: &mut crate::CodegenCx<'clif, 'tcx, B>,
instance: Instance<'tcx>,
linkage: Linkage,
@ -202,7 +202,7 @@ pub fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
context.clear();
}
pub fn verify_func(tcx: TyCtxt, writer: &crate::pretty_clif::CommentWriter, func: &Function) {
pub(crate) fn verify_func(tcx: TyCtxt, writer: &crate::pretty_clif::CommentWriter, func: &Function) {
tcx.sess.time("verify clif ir", || {
let flags = settings::Flags::new(settings::builder());
match ::cranelift_codegen::verify_function(&func, &flags) {
@ -724,7 +724,7 @@ fn codegen_array_len<'tcx>(
}
}
pub fn trans_place<'tcx>(
pub(crate) fn trans_place<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
place: &Place<'tcx>,
) -> CPlace<'tcx> {
@ -792,7 +792,7 @@ pub fn trans_place<'tcx>(
cplace
}
pub fn trans_operand<'tcx>(
pub(crate) fn trans_operand<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
operand: &Operand<'tcx>,
) -> CValue<'tcx> {

4
src/cast.rs
View File

@ -1,6 +1,6 @@
use crate::prelude::*;
pub fn clif_intcast(
pub(crate) fn clif_intcast(
fx: &mut FunctionCx<'_, '_, impl Backend>,
val: Value,
to: Type,
@ -48,7 +48,7 @@ pub fn clif_intcast(
}
}
pub fn clif_int_or_float_cast(
pub(crate) fn clif_int_or_float_cast(
fx: &mut FunctionCx<'_, '_, impl Backend>,
from: Value,
from_signed: bool,

2
src/codegen_i128.rs
View File

@ -2,7 +2,7 @@
use crate::prelude::*;
pub fn maybe_codegen<'tcx>(
pub(crate) fn maybe_codegen<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
checked: bool,

62
src/common.rs
View File

@ -6,11 +6,11 @@ use cranelift_codegen::ir::{InstructionData, Opcode, ValueDef};
use crate::prelude::*;
pub fn mir_var(loc: Local) -> Variable {
pub(crate) fn mir_var(loc: Local) -> Variable {
Variable::with_u32(loc.index() as u32)
}
pub fn pointer_ty(tcx: TyCtxt) -> types::Type {
pub(crate) fn pointer_ty(tcx: TyCtxt) -> types::Type {
match tcx.data_layout.pointer_size.bits() {
16 => types::I16,
32 => types::I32,
@ -19,7 +19,7 @@ pub fn pointer_ty(tcx: TyCtxt) -> types::Type {
}
}
pub fn scalar_to_clif_type(tcx: TyCtxt, scalar: Scalar) -> Type {
pub(crate) fn scalar_to_clif_type(tcx: TyCtxt, scalar: Scalar) -> Type {
match scalar.value {
Primitive::Int(int, _sign) => match int {
Integer::I8 => types::I8,
@ -72,7 +72,7 @@ fn clif_type_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<types::Typ
}
/// Is a pointer to this type a fat ptr?
pub fn has_ptr_meta<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
pub(crate) fn has_ptr_meta<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
let ptr_ty = tcx.mk_ptr(TypeAndMut { ty, mutbl: rustc_hir::Mutability::Not });
match &tcx.layout_of(ParamEnv::reveal_all().and(ptr_ty)).unwrap().abi {
Abi::Scalar(_) => false,
@ -81,7 +81,7 @@ pub fn has_ptr_meta<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
}
}
pub fn codegen_icmp(
pub(crate) fn codegen_icmp(
fx: &mut FunctionCx<'_, '_, impl Backend>,
intcc: IntCC,
lhs: Value,
@ -126,7 +126,7 @@ pub fn codegen_icmp(
}
}
pub fn codegen_icmp_imm(
pub(crate) fn codegen_icmp_imm(
fx: &mut FunctionCx<'_, '_, impl Backend>,
intcc: IntCC,
lhs: Value,
@ -207,7 +207,7 @@ fn resolve_128bit_value_imm(func: &Function, val: Value) -> Option<u128> {
Some(msb << 64 | lsb)
}
pub fn resolve_value_imm(func: &Function, val: Value) -> Option<u128> {
pub(crate) fn resolve_value_imm(func: &Function, val: Value) -> Option<u128> {
if func.dfg.value_type(val) == types::I128 {
resolve_128bit_value_imm(func, val)
} else {
@ -215,7 +215,7 @@ pub fn resolve_value_imm(func: &Function, val: Value) -> Option<u128> {
}
}
pub fn type_min_max_value(ty: Type, signed: bool) -> (i64, i64) {
pub(crate) fn type_min_max_value(ty: Type, signed: bool) -> (i64, i64) {
assert!(ty.is_int());
let min = match (ty, signed) {
(types::I8, false) | (types::I16, false) | (types::I32, false) | (types::I64, false) => {
@ -245,7 +245,7 @@ pub fn type_min_max_value(ty: Type, signed: bool) -> (i64, i64) {
(min, max)
}
pub fn type_sign(ty: Ty<'_>) -> bool {
pub(crate) fn type_sign(ty: Ty<'_>) -> bool {
match ty.kind {
ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..) | ty::Char | ty::Uint(..) | ty::Bool => false,
ty::Int(..) => true,
@ -254,30 +254,30 @@ pub fn type_sign(ty: Ty<'_>) -> bool {
}
}
pub struct FunctionCx<'clif, 'tcx, B: Backend + 'static> {
pub(crate) struct FunctionCx<'clif, 'tcx, B: Backend + 'static> {
// FIXME use a reference to `CodegenCx` instead of `tcx`, `module` and `constants` and `caches`
pub tcx: TyCtxt<'tcx>,
pub module: &'clif mut Module<B>,
pub pointer_type: Type, // Cached from module
pub(crate) tcx: TyCtxt<'tcx>,
pub(crate) module: &'clif mut Module<B>,
pub(crate) pointer_type: Type, // Cached from module
pub instance: Instance<'tcx>,
pub mir: &'tcx Body<'tcx>,
pub(crate) instance: Instance<'tcx>,
pub(crate) mir: &'tcx Body<'tcx>,
pub bcx: FunctionBuilder<'clif>,
pub block_map: IndexVec<BasicBlock, Block>,
pub local_map: HashMap<Local, CPlace<'tcx>>,
pub(crate) bcx: FunctionBuilder<'clif>,
pub(crate) block_map: IndexVec<BasicBlock, Block>,
pub(crate) local_map: HashMap<Local, CPlace<'tcx>>,
/// When `#[track_caller]` is used, the implicit caller location is stored in this variable.
pub caller_location: Option<CValue<'tcx>>,
pub(crate) caller_location: Option<CValue<'tcx>>,
/// See [crate::optimize::code_layout] for more information.
pub cold_blocks: EntitySet<Block>,
pub(crate) cold_blocks: EntitySet<Block>,
pub clif_comments: crate::pretty_clif::CommentWriter,
pub constants_cx: &'clif mut crate::constant::ConstantCx,
pub vtables: &'clif mut HashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
pub(crate) clif_comments: crate::pretty_clif::CommentWriter,
pub(crate) constants_cx: &'clif mut crate::constant::ConstantCx,
pub(crate) vtables: &'clif mut HashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
pub source_info_set: indexmap::IndexSet<SourceInfo>,
pub(crate) source_info_set: indexmap::IndexSet<SourceInfo>,
}
impl<'tcx, B: Backend> LayoutOf for FunctionCx<'_, 'tcx, B> {
@ -333,7 +333,7 @@ impl<'tcx, B: Backend> BackendTypes for FunctionCx<'_, 'tcx, B> {
}
impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
pub fn monomorphize<T>(&self, value: &T) -> T
pub(crate) fn monomorphize<T>(&self, value: &T) -> T
where
T: TypeFoldable<'tcx>,
{
@ -344,26 +344,26 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
)
}
pub fn clif_type(&self, ty: Ty<'tcx>) -> Option<Type> {
pub(crate) fn clif_type(&self, ty: Ty<'tcx>) -> Option<Type> {
clif_type_from_ty(self.tcx, ty)
}
pub fn get_block(&self, bb: BasicBlock) -> Block {
pub(crate) fn get_block(&self, bb: BasicBlock) -> Block {
*self.block_map.get(bb).unwrap()
}
pub fn get_local_place(&mut self, local: Local) -> CPlace<'tcx> {
pub(crate) fn get_local_place(&mut self, local: Local) -> CPlace<'tcx> {
*self.local_map.get(&local).unwrap_or_else(|| {
panic!("Local {:?} doesn't exist", local);
})
}
pub fn set_debug_loc(&mut self, source_info: mir::SourceInfo) {
pub(crate) fn set_debug_loc(&mut self, source_info: mir::SourceInfo) {
let (index, _) = self.source_info_set.insert_full(source_info);
self.bcx.set_srcloc(SourceLoc::new(index as u32));
}
pub fn get_caller_location(&mut self, span: Span) -> CValue<'tcx> {
pub(crate) fn get_caller_location(&mut self, span: Span) -> CValue<'tcx> {
if let Some(loc) = self.caller_location {
// `#[track_caller]` is used; return caller location instead of current location.
return loc;
@ -382,7 +382,7 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
)
}
pub fn triple(&self) -> &target_lexicon::Triple {
pub(crate) fn triple(&self) -> &target_lexicon::Triple {
self.module.isa().triple()
}
}

12
src/constant.rs
View File

@ -19,7 +19,7 @@ use cranelift_module::*;
use crate::prelude::*;
#[derive(Default)]
pub struct ConstantCx {
pub(crate) struct ConstantCx {
todo: Vec<TodoItem>,
done: FxHashSet<DataId>,
}
@ -31,7 +31,7 @@ enum TodoItem {
}
impl ConstantCx {
pub fn finalize(mut self, tcx: TyCtxt<'_>, module: &mut Module<impl Backend>) {
pub(crate) fn finalize(mut self, tcx: TyCtxt<'_>, module: &mut Module<impl Backend>) {
//println!("todo {:?}", self.todo);
define_all_allocs(tcx, module, &mut self);
//println!("done {:?}", self.done);
@ -39,7 +39,7 @@ impl ConstantCx {
}
}
pub fn codegen_static(constants_cx: &mut ConstantCx, def_id: DefId) {
pub(crate) fn codegen_static(constants_cx: &mut ConstantCx, def_id: DefId) {
constants_cx.todo.push(TodoItem::Static(def_id));
}
@ -56,7 +56,7 @@ fn codegen_static_ref<'tcx>(
cplace_for_dataid(fx, layout, local_data_id)
}
pub fn trans_constant<'tcx>(
pub(crate) fn trans_constant<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
constant: &Constant<'tcx>,
) -> CValue<'tcx> {
@ -77,7 +77,7 @@ pub fn trans_constant<'tcx>(
trans_const_value(fx, const_)
}
pub fn trans_const_value<'tcx>(
pub(crate) fn trans_const_value<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
const_: &'tcx Const<'tcx>,
) -> CValue<'tcx> {
@ -489,7 +489,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for TransPlaceInterpreter {
}
}
pub fn mir_operand_get_const_val<'tcx>(
pub(crate) fn mir_operand_get_const_val<'tcx>(
fx: &FunctionCx<'_, 'tcx, impl Backend>,
operand: &Operand<'tcx>,
) -> Option<&'tcx Const<'tcx>> {

14
src/debuginfo/emit.rs
View File

@ -8,7 +8,7 @@ use crate::backend::WriteDebugInfo;
use super::DebugContext;
impl DebugContext<'_> {
pub fn emit<P: WriteDebugInfo>(&mut self, product: &mut P) {
pub(crate) fn emit<P: WriteDebugInfo>(&mut self, product: &mut P) {
let unit_range_list_id = self.dwarf.unit.ranges.add(self.unit_range_list.clone());
let root = self.dwarf.unit.root();
let root = self.dwarf.unit.get_mut(root);
@ -41,15 +41,15 @@ impl DebugContext<'_> {
}
#[derive(Clone)]
pub struct DebugReloc {
pub offset: u32,
pub size: u8,
pub name: DebugRelocName,
pub addend: i64,
pub(crate) struct DebugReloc {
pub(crate) offset: u32,
pub(crate) size: u8,
pub(crate) name: DebugRelocName,
pub(crate) addend: i64,
}
#[derive(Clone)]
pub enum DebugRelocName {
pub(crate) enum DebugRelocName {
Section(SectionId),
Symbol(usize),
}

4
src/debuginfo/line_info.rs
View File

@ -3,7 +3,7 @@ use std::path::{Component, Path};
use crate::prelude::*;
use rustc_span::{FileName, SourceFileAndLine};
use rustc_span::{FileName, SourceFileAndLine, Pos};
use cranelift_codegen::binemit::CodeOffset;
@ -162,7 +162,7 @@ impl<'a, 'tcx> FunctionDebugContext<'a, 'tcx> {
let current_file_changed = if let Some(last_file) = &last_file {
// If the allocations are not equal, then the files may still be equal, but that
// is not a problem, as this is just an optimization.
!Lrc::ptr_eq(last_file, &file)
!rustc_data_structures::sync::Lrc::ptr_eq(last_file, &file)
} else {
true
};

12
src/debuginfo/mod.rs
View File

@ -13,7 +13,7 @@ use gimli::write::{
};
use gimli::{Encoding, Format, LineEncoding, Register, RunTimeEndian, X86_64};
pub use emit::{DebugReloc, DebugRelocName};
pub(crate) use emit::{DebugReloc, DebugRelocName};
fn target_endian(tcx: TyCtxt) -> RunTimeEndian {
use rustc::ty::layout::Endian;
@ -24,7 +24,7 @@ fn target_endian(tcx: TyCtxt) -> RunTimeEndian {
}
}
pub struct DebugContext<'tcx> {
pub(crate) struct DebugContext<'tcx> {
tcx: TyCtxt<'tcx>,
endian: RunTimeEndian,
@ -37,7 +37,7 @@ pub struct DebugContext<'tcx> {
}
impl<'tcx> DebugContext<'tcx> {
pub fn new(tcx: TyCtxt<'tcx>, address_size: u8) -> Self {
pub(crate) fn new(tcx: TyCtxt<'tcx>, address_size: u8) -> Self {
let encoding = Encoding {
format: Format::Dwarf32,
// TODO: this should be configurable
@ -187,7 +187,7 @@ impl<'tcx> DebugContext<'tcx> {
}
}
pub struct FunctionDebugContext<'a, 'tcx> {
pub(crate) struct FunctionDebugContext<'a, 'tcx> {
debug_context: &'a mut DebugContext<'tcx>,
entry_id: UnitEntryId,
symbol: usize,
@ -196,7 +196,7 @@ pub struct FunctionDebugContext<'a, 'tcx> {
}
impl<'a, 'tcx> FunctionDebugContext<'a, 'tcx> {
pub fn new(
pub(crate) fn new(
debug_context: &'a mut DebugContext<'tcx>,
instance: Instance<'tcx>,
func_id: FuncId,
@ -250,7 +250,7 @@ impl<'a, 'tcx> FunctionDebugContext<'a, 'tcx> {
var_id
}
pub fn define(
pub(crate) fn define(
&mut self,
context: &Context,
isa: &dyn TargetIsa,

4
src/discriminant.rs
View File

@ -2,7 +2,7 @@
use crate::prelude::*;
pub fn codegen_set_discriminant<'tcx>(
pub(crate) fn codegen_set_discriminant<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
place: CPlace<'tcx>,
variant_index: VariantIdx,
@ -52,7 +52,7 @@ pub fn codegen_set_discriminant<'tcx>(
}
}
pub fn codegen_get_discriminant<'tcx>(
pub(crate) fn codegen_get_discriminant<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
value: CValue<'tcx>,
dest_layout: TyLayout<'tcx>,

2
src/driver/jit.rs
View File

@ -89,7 +89,7 @@ fn load_imported_symbols_for_jit(tcx: TyCtxt<'_>) -> Vec<(String, *const u8)> {
let formats = tcx.dependency_formats(LOCAL_CRATE);
let data = &formats
.iter()
.find(|(crate_type, _data)| *crate_type == CrateType::Executable)
.find(|(crate_type, _data)| *crate_type == rustc_session::config::CrateType::Executable)
.unwrap()
.1;
for &(cnum, _) in &crate_info.used_crates_dynamic {

6
src/driver/mod.rs
View File

@ -1,7 +1,7 @@
use std::any::Any;
use rustc::middle::cstore::EncodedMetadata;
use rustc::mir::mono::{Linkage as RLinkage, Visibility};
use rustc::mir::mono::{Linkage as RLinkage, MonoItem, Visibility};
use crate::prelude::*;
@ -9,7 +9,7 @@ mod aot;
#[cfg(not(target_arch = "wasm32"))]
mod jit;
pub fn codegen_crate(
pub(crate) fn codegen_crate(
tcx: TyCtxt<'_>,
metadata: EncodedMetadata,
need_metadata_module: bool,
@ -17,7 +17,7 @@ pub fn codegen_crate(
tcx.sess.abort_if_errors();
if std::env::var("CG_CLIF_JIT").is_ok()
&& tcx.sess.crate_types.get().contains(&CrateType::Executable)
&& tcx.sess.crate_types.get().contains(&rustc_session::config::CrateType::Executable)
{
#[cfg(not(target_arch = "wasm32"))]
let _: ! = jit::run_jit(tcx);

2
src/intrinsics/llvm.rs
View File

@ -3,7 +3,7 @@ use crate::prelude::*;
use rustc::ty::subst::SubstsRef;
pub fn codegen_llvm_intrinsic_call<'tcx>(
pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
intrinsic: &str,
substs: SubstsRef<'tcx>,

6
src/intrinsics/mod.rs
View File

@ -1,6 +1,8 @@
pub mod llvm;
mod llvm;
mod simd;
pub(crate) use llvm::codegen_llvm_intrinsic_call;
use crate::prelude::*;
macro intrinsic_pat {
@ -332,7 +334,7 @@ macro simd_flt_binop($fx:expr, $op:ident($x:ident, $y:ident) -> $ret:ident) {
);
}
pub fn codegen_intrinsic_call<'tcx>(
pub(crate) fn codegen_intrinsic_call<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
instance: Instance<'tcx>,
args: &[mir::Operand<'tcx>],

92
src/lib.rs
View File

@ -62,62 +62,52 @@ mod value_and_place;
mod vtable;
mod prelude {
pub use std::any::Any;
pub use std::collections::{HashMap, HashSet};
pub use std::convert::{TryFrom, TryInto};
pub(crate) use std::collections::HashMap;
pub(crate) use std::convert::{TryFrom, TryInto};
pub use rustc_ast::ast::{FloatTy, IntTy, UintTy};
pub use rustc_span::{Pos, Span};
pub(crate) use rustc_ast::ast::{FloatTy, IntTy, UintTy};
pub(crate) use rustc_span::Span;
pub use rustc::bug;
pub use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
pub use rustc::mir::{self, interpret::AllocId, mono::MonoItem, *};
pub use rustc_session::{
config::{CrateType, Lto},
Session,
};
pub use rustc::ty::layout::{self, Abi, LayoutOf, Scalar, Size, TyLayout, VariantIdx};
pub use rustc::ty::{
self, FnSig, Instance, InstanceDef, ParamEnv, PolyFnSig, Ty, TyCtxt, TypeAndMut,
TypeFoldable,
pub(crate) use rustc::bug;
pub(crate) use rustc_hir::def_id::{DefId, LOCAL_CRATE};
pub(crate) use rustc::mir::{self, *};
pub(crate) use rustc_session::Session;
pub(crate) use rustc::ty::layout::{self, Abi, LayoutOf, Scalar, Size, TyLayout, VariantIdx};
pub(crate) use rustc::ty::{
self, FnSig, Instance, InstanceDef, ParamEnv, Ty, TyCtxt, TypeAndMut, TypeFoldable,
};
pub use rustc_data_structures::{
fx::{FxHashMap, FxHashSet},
sync::Lrc,
pub(crate) use rustc_data_structures::fx::FxHashMap;
pub(crate) use rustc_index::vec::Idx;
pub(crate) use rustc_codegen_ssa::traits::*;
pub(crate) use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleKind};
pub(crate) use cranelift_codegen::Context;
pub(crate) use cranelift_codegen::entity::EntitySet;
pub(crate) use cranelift_codegen::ir::{AbiParam, Block, ExternalName, FuncRef, Inst, InstBuilder, MemFlags, Signature, SourceLoc, StackSlot, StackSlotData, StackSlotKind, TrapCode, Type, Value};
pub(crate) use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
pub(crate) use cranelift_codegen::ir::function::Function;
pub(crate) use cranelift_codegen::ir::types;
pub(crate) use cranelift_codegen::isa::{self, CallConv};
pub(crate) use cranelift_codegen::settings::{self, Configurable};
pub(crate) use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
pub(crate) use cranelift_module::{
self, Backend, DataContext, DataId, FuncId, Linkage, Module,
};
pub use rustc_index::vec::Idx;
pub(crate) use crate::abi::*;
pub(crate) use crate::base::{trans_operand, trans_place};
pub(crate) use crate::cast::*;
pub(crate) use crate::common::*;
pub(crate) use crate::debuginfo::{DebugContext, FunctionDebugContext};
pub(crate) use crate::pointer::Pointer;
pub(crate) use crate::trap::*;
pub(crate) use crate::value_and_place::{CPlace, CPlaceInner, CValue};
pub(crate) use crate::CodegenCx;
pub use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
pub use rustc_codegen_ssa::traits::*;
pub use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleKind};
pub use cranelift_codegen::Context;
pub use cranelift_codegen::entity::EntitySet;
pub use cranelift_codegen::ir::{AbiParam, Block, ExternalName, FuncRef, Inst, InstBuilder, MemFlags, Signature, SourceLoc, StackSlot, StackSlotData, StackSlotKind, TrapCode, Type, Value};
pub use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
pub use cranelift_codegen::ir::function::Function;
pub use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
pub use cranelift_codegen::ir::types;
pub use cranelift_codegen::isa::{self, CallConv};
pub use cranelift_codegen::settings::{self, Configurable};
pub use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
pub use cranelift_module::{
self, Backend, DataContext, DataId, FuncId, FuncOrDataId, Linkage, Module,
};
pub use crate::abi::*;
pub use crate::base::{trans_operand, trans_place};
pub use crate::cast::*;
pub use crate::common::*;
pub use crate::debuginfo::{DebugContext, FunctionDebugContext};
pub use crate::pointer::Pointer;
pub use crate::trap::*;
pub use crate::value_and_place::{CPlace, CPlaceInner, CValue};
pub use crate::CodegenCx;
pub struct PrintOnPanic<F: Fn() -> String>(pub F);
pub(crate) struct PrintOnPanic<F: Fn() -> String>(pub F);
impl<F: Fn() -> String> Drop for PrintOnPanic<F> {
fn drop(&mut self) {
if ::std::thread::panicking() {
@ -126,12 +116,12 @@ mod prelude {
}
}
pub macro unimpl_fatal($tcx:expr, $span:expr, $($tt:tt)*) {
pub(crate) macro unimpl_fatal($tcx:expr, $span:expr, $($tt:tt)*) {
$tcx.sess.span_fatal($span, &format!($($tt)*));
}
}
pub struct CodegenCx<'clif, 'tcx, B: Backend + 'static> {
pub(crate) struct CodegenCx<'clif, 'tcx, B: Backend + 'static> {
tcx: TyCtxt<'tcx>,
module: &'clif mut Module<B>,
constants_cx: ConstantCx,

4
src/linkage.rs
View File

@ -2,7 +2,7 @@ use rustc::mir::mono::{Linkage as RLinkage, MonoItem, Visibility};
use crate::prelude::*;
pub fn get_clif_linkage(mono_item: MonoItem, linkage: RLinkage, visibility: Visibility) -> Linkage {
pub(crate) fn get_clif_linkage(mono_item: MonoItem, linkage: RLinkage, visibility: Visibility) -> Linkage {
match (linkage, visibility) {
(RLinkage::External, Visibility::Default) => Linkage::Export,
(RLinkage::Internal, Visibility::Default) => Linkage::Local,
@ -11,7 +11,7 @@ pub fn get_clif_linkage(mono_item: MonoItem, linkage: RLinkage, visibility: Visi
}
}
pub fn get_static_ref_linkage(tcx: TyCtxt, def_id: DefId) -> Linkage {
pub(crate) fn get_static_ref_linkage(tcx: TyCtxt, def_id: DefId) -> Linkage {
let fn_attrs = tcx.codegen_fn_attrs(def_id);
if let Some(linkage) = fn_attrs.linkage {

2
src/main_shim.rs
View File

@ -2,7 +2,7 @@ use crate::prelude::*;
/// Create the `main` function which will initialize the rust runtime and call
/// users main function.
pub fn maybe_create_entry_wrapper(tcx: TyCtxt<'_>, module: &mut Module<impl Backend + 'static>) {
pub(crate) fn maybe_create_entry_wrapper(tcx: TyCtxt<'_>, module: &mut Module<impl Backend + 'static>) {
use rustc::middle::lang_items::StartFnLangItem;
use rustc_session::config::EntryFnType;

4
src/metadata.rs
View File

@ -12,7 +12,7 @@ use rustc_target::spec::Target;
use crate::backend::WriteMetadata;
pub struct CraneliftMetadataLoader;
pub(crate) struct CraneliftMetadataLoader;
impl MetadataLoader for CraneliftMetadataLoader {
fn get_rlib_metadata(
@ -59,7 +59,7 @@ impl MetadataLoader for CraneliftMetadataLoader {
}
// Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
pub fn write_metadata<P: WriteMetadata>(tcx: TyCtxt<'_>, product: &mut P) -> EncodedMetadata {
pub(crate) fn write_metadata<P: WriteMetadata>(tcx: TyCtxt<'_>, product: &mut P) -> EncodedMetadata {
use flate2::write::DeflateEncoder;
use flate2::Compression;
use std::io::Write;

14
src/num.rs
View File

@ -1,6 +1,6 @@
use crate::prelude::*;
pub fn bin_op_to_intcc(bin_op: BinOp, signed: bool) -> Option<IntCC> {
pub(crate) fn bin_op_to_intcc(bin_op: BinOp, signed: bool) -> Option<IntCC> {
use BinOp::*;
use IntCC::*;
Some(match bin_op {
@ -51,7 +51,7 @@ fn codegen_compare_bin_op<'tcx>(
CValue::by_val(val, fx.layout_of(fx.tcx.types.bool))
}
pub fn codegen_binop<'tcx>(
pub(crate) fn codegen_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,
@ -100,7 +100,7 @@ pub fn codegen_binop<'tcx>(
}
}
pub fn trans_bool_binop<'tcx>(
pub(crate) fn trans_bool_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,
@ -121,7 +121,7 @@ pub fn trans_bool_binop<'tcx>(
CValue::by_val(res, fx.layout_of(fx.tcx.types.bool))
}
pub fn trans_int_binop<'tcx>(
pub(crate) fn trans_int_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,
@ -192,7 +192,7 @@ pub fn trans_int_binop<'tcx>(
CValue::by_val(val, in_lhs.layout())
}
pub fn trans_checked_int_binop<'tcx>(
pub(crate) fn trans_checked_int_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,
@ -297,7 +297,7 @@ pub fn trans_checked_int_binop<'tcx>(
out_place.to_cvalue(fx)
}
pub fn trans_float_binop<'tcx>(
pub(crate) fn trans_float_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,
@ -342,7 +342,7 @@ pub fn trans_float_binop<'tcx>(
CValue::by_val(res, in_lhs.layout())
}
pub fn trans_ptr_binop<'tcx>(
pub(crate) fn trans_ptr_binop<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
bin_op: BinOp,
in_lhs: CValue<'tcx>,

2
src/optimize/mod.rs
View File

@ -3,7 +3,7 @@ use crate::prelude::*;
mod code_layout;
mod stack2reg;
pub fn optimize_function<'tcx>(
pub(crate) fn optimize_function<'tcx>(
tcx: TyCtxt<'tcx>,
#[cfg_attr(not(debug_assertions), allow(unused_variables))]
instance: Instance<'tcx>,

24
src/pointer.rs
View File

@ -3,33 +3,33 @@ use crate::prelude::*;
use cranelift_codegen::ir::immediates::Offset32;
#[derive(Copy, Clone, Debug)]
pub struct Pointer {
pub(crate) struct Pointer {
base: PointerBase,
offset: Offset32,
}
#[derive(Copy, Clone, Debug)]
pub enum PointerBase {
pub(crate) enum PointerBase {
Addr(Value),
Stack(StackSlot),
}
impl Pointer {
pub fn new(addr: Value) -> Self {
pub(crate) fn new(addr: Value) -> Self {
Pointer {
base: PointerBase::Addr(addr),
offset: Offset32::new(0),
}
}
pub fn stack_slot(stack_slot: StackSlot) -> Self {
pub(crate) fn stack_slot(stack_slot: StackSlot) -> Self {
Pointer {
base: PointerBase::Stack(stack_slot),
offset: Offset32::new(0),
}
}
pub fn const_addr<'a, 'tcx>(fx: &mut FunctionCx<'a, 'tcx, impl Backend>, addr: i64) -> Self {
pub(crate) fn const_addr<'a, 'tcx>(fx: &mut FunctionCx<'a, 'tcx, impl Backend>, addr: i64) -> Self {
let addr = fx.bcx.ins().iconst(fx.pointer_type, addr);
Pointer {
base: PointerBase::Addr(addr),
@ -38,11 +38,11 @@ impl Pointer {
}
#[cfg(debug_assertions)]
pub fn base_and_offset(self) -> (PointerBase, Offset32) {
pub(crate) fn base_and_offset(self) -> (PointerBase, Offset32) {
(self.base, self.offset)
}
pub fn get_addr<'a, 'tcx>(self, fx: &mut FunctionCx<'a, 'tcx, impl Backend>) -> Value {
pub(crate) fn get_addr<'a, 'tcx>(self, fx: &mut FunctionCx<'a, 'tcx, impl Backend>) -> Value {
match self.base {
PointerBase::Addr(base_addr) => {
let offset: i64 = self.offset.into();
@ -56,7 +56,7 @@ impl Pointer {
}
}
pub fn offset<'a, 'tcx>(
pub(crate) fn offset<'a, 'tcx>(
self,
fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
extra_offset: Offset32,
@ -64,7 +64,7 @@ impl Pointer {
self.offset_i64(fx, extra_offset.into())
}
pub fn offset_i64<'a, 'tcx>(
pub(crate) fn offset_i64<'a, 'tcx>(
self,
fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
extra_offset: i64,
@ -92,7 +92,7 @@ impl Pointer {
}
}
pub fn offset_value<'a, 'tcx>(
pub(crate) fn offset_value<'a, 'tcx>(
self,
fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
extra_offset: Value,
@ -112,7 +112,7 @@ impl Pointer {
}
}
pub fn load<'a, 'tcx>(
pub(crate) fn load<'a, 'tcx>(
self,
fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
ty: Type,
@ -130,7 +130,7 @@ impl Pointer {
}
}
pub fn store<'a, 'tcx>(
pub(crate) fn store<'a, 'tcx>(
self,
fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
value: Value,

14
src/pretty_clif.rs
View File

@ -64,13 +64,13 @@ use crate::prelude::*;
/// ```
#[derive(Debug)]
pub struct CommentWriter {
pub(crate) struct CommentWriter {
global_comments: Vec<String>,
entity_comments: HashMap<AnyEntity, String>,
}
impl CommentWriter {
pub fn new<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self {
pub(crate) fn new<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self {
let global_comments = if cfg!(debug_assertions) {
vec![
format!("symbol {}", tcx.symbol_name(instance).name.as_str()),
@ -97,11 +97,11 @@ impl CommentWriter {
#[cfg(debug_assertions)]
impl CommentWriter {
pub fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
pub(crate) fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
self.global_comments.push(comment.into());
}
pub fn add_comment<S: Into<String> + AsRef<str>, E: Into<AnyEntity>>(
pub(crate) fn add_comment<S: Into<String> + AsRef<str>, E: Into<AnyEntity>>(
&mut self,
entity: E,
comment: S,
@ -186,11 +186,11 @@ impl FuncWriter for &'_ CommentWriter {
#[cfg(debug_assertions)]
impl<'a, 'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
pub fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
pub(crate) fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
self.clif_comments.add_global_comment(comment);
}
pub fn add_comment<S: Into<String> + AsRef<str>, E: Into<AnyEntity>>(
pub(crate) fn add_comment<S: Into<String> + AsRef<str>, E: Into<AnyEntity>>(
&mut self,
entity: E,
comment: S,
@ -200,7 +200,7 @@ impl<'a, 'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> {
}
#[cfg(debug_assertions)]
pub fn write_clif_file<'tcx>(
pub(crate) fn write_clif_file<'tcx>(
tcx: TyCtxt<'tcx>,
postfix: &str,
instance: Instance<'tcx>,

4
src/target_features_whitelist.rs
View File

@ -115,7 +115,7 @@ const WASM_WHITELIST: &[(&str, Option<Symbol>)] = &[
///
/// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this
/// iterator!
pub fn all_known_features() -> impl Iterator<Item = (&'static str, Option<Symbol>)> {
pub(crate) fn all_known_features() -> impl Iterator<Item = (&'static str, Option<Symbol>)> {
ARM_WHITELIST
.iter()
.cloned()
@ -127,7 +127,7 @@ pub fn all_known_features() -> impl Iterator<Item = (&'static str, Option<Symbol
.chain(WASM_WHITELIST.iter().cloned())
}
pub fn target_feature_whitelist(sess: &Session) -> &'static [(&'static str, Option<Symbol>)] {
pub(crate) fn target_feature_whitelist(sess: &Session) -> &'static [(&'static str, Option<Symbol>)] {
match &*sess.target.target.arch {
"arm" => ARM_WHITELIST,
"aarch64" => AARCH64_WHITELIST,

10
src/trap.rs
View File

@ -55,7 +55,7 @@ fn codegen_print(fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>, ms
/// Use this when `rustc_codegen_llvm` would insert a call to the panic handler.
///
/// Trap code: user0
pub fn trap_panic(
pub(crate) fn trap_panic(
fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>,
msg: impl AsRef<str>,
) {
@ -67,7 +67,7 @@ pub fn trap_panic(
/// so you can **not** add instructions to it afterwards.
///
/// Trap code: user65535
pub fn trap_unreachable(
pub(crate) fn trap_unreachable(
fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>,
msg: impl AsRef<str>,
) {
@ -78,7 +78,7 @@ pub fn trap_unreachable(
/// Like `trap_unreachable` but returns a fake value of the specified type.
///
/// Trap code: user65535
pub fn trap_unreachable_ret_value<'tcx>(
pub(crate) fn trap_unreachable_ret_value<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl cranelift_module::Backend>,
dest_layout: TyLayout<'tcx>,
msg: impl AsRef<str>,
@ -92,7 +92,7 @@ pub fn trap_unreachable_ret_value<'tcx>(
/// to it afterwards.
///
/// Trap code: user65535
pub fn trap_unimplemented(
pub(crate) fn trap_unimplemented(
fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>,
msg: impl AsRef<str>,
) {
@ -104,7 +104,7 @@ pub fn trap_unimplemented(
/// Like `trap_unimplemented` but returns a fake value of the specified type.
///
/// Trap code: user65535
pub fn trap_unimplemented_ret_value<'tcx>(
pub(crate) fn trap_unimplemented_ret_value<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl cranelift_module::Backend>,
dest_layout: TyLayout<'tcx>,
msg: impl AsRef<str>,

6
src/unsize.rs
View File

@ -8,7 +8,7 @@ use crate::prelude::*;
/// The `old_info` argument is a bit funny. It is intended for use
/// in an upcast, where the new vtable for an object will be derived
/// from the old one.
pub fn unsized_info<'tcx>(
pub(crate) fn unsized_info<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
source: Ty<'tcx>,
target: Ty<'tcx>,
@ -84,7 +84,7 @@ fn unsize_thin_ptr<'tcx>(
/// Coerce `src`, which is a reference to a value of type `src_ty`,
/// to a value of type `dst_ty` and store the result in `dst`
pub fn coerce_unsized_into<'tcx>(
pub(crate) fn coerce_unsized_into<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
src: CValue<'tcx>,
dst: CPlace<'tcx>,
@ -137,7 +137,7 @@ pub fn coerce_unsized_into<'tcx>(
// Adapted from https://github.com/rust-lang/rust/blob/2a663555ddf36f6b041445894a8c175cd1bc718c/src/librustc_codegen_ssa/glue.rs
pub fn size_and_align_of_dst<'tcx>(
pub(crate) fn size_and_align_of_dst<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
layout: TyLayout<'tcx>,
info: Value,

68
src/value_and_place.rs
View File

@ -62,7 +62,7 @@ fn scalar_pair_calculate_b_offset(tcx: TyCtxt<'_>, a_scalar: &Scalar, b_scalar:
/// A read-only value
#[derive(Debug, Copy, Clone)]
pub struct CValue<'tcx>(CValueInner, TyLayout<'tcx>);
pub(crate) struct CValue<'tcx>(CValueInner, TyLayout<'tcx>);
#[derive(Debug, Copy, Clone)]
enum CValueInner {
@ -72,28 +72,28 @@ enum CValueInner {
}
impl<'tcx> CValue<'tcx> {
pub fn by_ref(ptr: Pointer, layout: TyLayout<'tcx>) -> CValue<'tcx> {
pub(crate) fn by_ref(ptr: Pointer, layout: TyLayout<'tcx>) -> CValue<'tcx> {
CValue(CValueInner::ByRef(ptr, None), layout)
}
pub fn by_ref_unsized(ptr: Pointer, meta: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
pub(crate) fn by_ref_unsized(ptr: Pointer, meta: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
CValue(CValueInner::ByRef(ptr, Some(meta)), layout)
}
pub fn by_val(value: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
pub(crate) fn by_val(value: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
CValue(CValueInner::ByVal(value), layout)
}
pub fn by_val_pair(value: Value, extra: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
pub(crate) fn by_val_pair(value: Value, extra: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
CValue(CValueInner::ByValPair(value, extra), layout)
}
pub fn layout(&self) -> TyLayout<'tcx> {
pub(crate) fn layout(&self) -> TyLayout<'tcx> {
self.1
}
// FIXME remove
pub fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> (Pointer, Option<Value>) {
pub(crate) fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> (Pointer, Option<Value>) {
let layout = self.1;
match self.0 {
CValueInner::ByRef(ptr, meta) => (ptr, meta),
@ -105,7 +105,7 @@ impl<'tcx> CValue<'tcx> {
}
}
pub fn try_to_ptr(self) -> Option<(Pointer, Option<Value>)> {
pub(crate) fn try_to_ptr(self) -> Option<(Pointer, Option<Value>)> {
match self.0 {
CValueInner::ByRef(ptr, meta) => Some((ptr, meta)),
CValueInner::ByVal(_) | CValueInner::ByValPair(_, _) => None,
@ -113,7 +113,7 @@ impl<'tcx> CValue<'tcx> {
}
/// Load a value with layout.abi of scalar
pub fn load_scalar<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Value {
pub(crate) fn load_scalar<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Value {
let layout = self.1;
match self.0 {
CValueInner::ByRef(ptr, None) => {
@ -134,7 +134,7 @@ impl<'tcx> CValue<'tcx> {
}
/// Load a value pair with layout.abi of scalar pair
pub fn load_scalar_pair<'a>(
pub(crate) fn load_scalar_pair<'a>(
self,
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
) -> (Value, Value) {
@ -158,7 +158,7 @@ impl<'tcx> CValue<'tcx> {
}
}
pub fn value_field<'a>(
pub(crate) fn value_field<'a>(
self,
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
field: mir::Field,
@ -187,16 +187,18 @@ impl<'tcx> CValue<'tcx> {
}
}
pub fn unsize_value<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, dest: CPlace<'tcx>) {
pub(crate) fn unsize_value<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, dest: CPlace<'tcx>) {
crate::unsize::coerce_unsized_into(fx, self, dest);
}
/// If `ty` is signed, `const_val` must already be sign extended.
pub fn const_val(
pub(crate) fn const_val(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
layout: TyLayout<'tcx>,
const_val: u128,
) -> CValue<'tcx> {
use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
let clif_ty = fx.clif_type(layout.ty).unwrap();
match layout.ty.kind {
@ -241,42 +243,42 @@ impl<'tcx> CValue<'tcx> {
CValue::by_val(val, layout)
}
pub fn unchecked_cast_to(self, layout: TyLayout<'tcx>) -> Self {
pub(crate) fn unchecked_cast_to(self, layout: TyLayout<'tcx>) -> Self {
CValue(self.0, layout)
}
}
/// A place where you can write a value to or read a value from
#[derive(Debug, Copy, Clone)]
pub struct CPlace<'tcx> {
pub(crate) struct CPlace<'tcx> {
inner: CPlaceInner,
layout: TyLayout<'tcx>,
}
#[derive(Debug, Copy, Clone)]
pub enum CPlaceInner {
pub(crate) enum CPlaceInner {
Var(Local),
Addr(Pointer, Option<Value>),
NoPlace,
}
impl<'tcx> CPlace<'tcx> {
pub fn layout(&self) -> TyLayout<'tcx> {
pub(crate) fn layout(&self) -> TyLayout<'tcx> {
self.layout
}
pub fn inner(&self) -> &CPlaceInner {
pub(crate) fn inner(&self) -> &CPlaceInner {
&self.inner
}
pub fn no_place(layout: TyLayout<'tcx>) -> CPlace<'tcx> {
pub(crate) fn no_place(layout: TyLayout<'tcx>) -> CPlace<'tcx> {
CPlace {
inner: CPlaceInner::NoPlace,
layout,
}
}
pub fn new_stack_slot(
pub(crate) fn new_stack_slot(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
layout: TyLayout<'tcx>,
) -> CPlace<'tcx> {
@ -299,7 +301,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn new_var(
pub(crate) fn new_var(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
local: Local,
layout: TyLayout<'tcx>,
@ -312,21 +314,21 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn for_ptr(ptr: Pointer, layout: TyLayout<'tcx>) -> CPlace<'tcx> {
pub(crate) fn for_ptr(ptr: Pointer, layout: TyLayout<'tcx>) -> CPlace<'tcx> {
CPlace {
inner: CPlaceInner::Addr(ptr, None),
layout,
}
}
pub fn for_ptr_with_extra(ptr: Pointer, extra: Value, layout: TyLayout<'tcx>) -> CPlace<'tcx> {
pub(crate) fn for_ptr_with_extra(ptr: Pointer, extra: Value, layout: TyLayout<'tcx>) -> CPlace<'tcx> {
CPlace {
inner: CPlaceInner::Addr(ptr, Some(extra)),
layout,
}
}
pub fn to_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> CValue<'tcx> {
pub(crate) fn to_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> CValue<'tcx> {
let layout = self.layout();
match self.inner {
CPlaceInner::Var(var) => {
@ -348,14 +350,14 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn to_ptr(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Pointer {
pub(crate) fn to_ptr(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Pointer {
match self.to_ptr_maybe_unsized(fx) {
(ptr, None) => ptr,
(_, Some(_)) => bug!("Expected sized cplace, found {:?}", self),
}
}
pub fn to_ptr_maybe_unsized(
pub(crate) fn to_ptr_maybe_unsized(
self,
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
) -> (Pointer, Option<Value>) {
@ -371,7 +373,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn write_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, from: CValue<'tcx>) {
pub(crate) fn write_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, from: CValue<'tcx>) {
#[cfg(debug_assertions)]
{
use cranelift_codegen::cursor::{Cursor, CursorPosition};
@ -516,7 +518,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn place_field(
pub(crate) fn place_field(
self,
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
field: mir::Field,
@ -532,7 +534,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn place_index(
pub(crate) fn place_index(
self,
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
index: Value,
@ -551,7 +553,7 @@ impl<'tcx> CPlace<'tcx> {
CPlace::for_ptr(ptr.offset_value(fx, offset), elem_layout)
}
pub fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> CPlace<'tcx> {
pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> CPlace<'tcx> {
let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
if has_ptr_meta(fx.tcx, inner_layout.ty) {
let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
@ -561,7 +563,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn write_place_ref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, dest: CPlace<'tcx>) {
pub(crate) fn write_place_ref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, dest: CPlace<'tcx>) {
if has_ptr_meta(fx.tcx, self.layout().ty) {
let (ptr, extra) = self.to_ptr_maybe_unsized(fx);
let ptr = CValue::by_val_pair(
@ -576,7 +578,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn unchecked_cast_to(self, layout: TyLayout<'tcx>) -> Self {
pub(crate) fn unchecked_cast_to(self, layout: TyLayout<'tcx>) -> Self {
assert!(!self.layout().is_unsized());
match self.inner {
CPlaceInner::NoPlace => {
@ -590,7 +592,7 @@ impl<'tcx> CPlace<'tcx> {
}
}
pub fn downcast_variant(
pub(crate) fn downcast_variant(
self,
fx: &FunctionCx<'_, 'tcx, impl Backend>,
variant: VariantIdx,

10
src/vtable.rs
View File

@ -12,7 +12,7 @@ fn vtable_memflags() -> MemFlags {
flags
}
pub fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
pub(crate) fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
fx.bcx.ins().load(
pointer_ty(fx.tcx),
@ -22,7 +22,7 @@ pub fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value)
)
}
pub fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
pub(crate) fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
fx.bcx.ins().load(
pointer_ty(fx.tcx),
@ -32,7 +32,7 @@ pub fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) ->
)
}
pub fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
pub(crate) fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
fx.bcx.ins().load(
pointer_ty(fx.tcx),
@ -42,7 +42,7 @@ pub fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value
)
}
pub fn get_ptr_and_method_ref<'tcx>(
pub(crate) fn get_ptr_and_method_ref<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
arg: CValue<'tcx>,
idx: usize,
@ -67,7 +67,7 @@ pub fn get_ptr_and_method_ref<'tcx>(
(ptr, func_ref)
}
pub fn get_vtable<'tcx>(
pub(crate) fn get_vtable<'tcx>(
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
layout: TyLayout<'tcx>,
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,