mii/wasmer
1
0
Fork 0
mirror of https://github.com/mii443/wasmer.git synced 2025-12-08 05:38:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add llvm 'readonly' attribute to calls of the memory size function.

Browse Source 
In passing, delete a lot of dead code. Remove old VM intrinsics for memory.size, memory.grow and breakpoints.
This commit is contained in:
Nick Lewycky
2020-05-22 16:55:57 -07:00
parent 17908b6b45
commit 630be7733d
2 changed files with 5 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/compiler-llvm/src/translator/code.rs
View File

@@ -7,6 +7,7 @@ use super::{
state::{ControlFrame, ExtraInfo, IfElseState, State},
};
use inkwell::{
attributes::AttributeLoc,
builder::Builder,
context::Context,
module::{Linkage, Module},
@@ -8245,6 +8246,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
],
"",
);
size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
self.state.push1(size.try_as_basic_value().left().unwrap());
}
_ => {

115
lib/compiler-llvm/src/translator/intrinsics.rs
View File

@@ -91,6 +91,7 @@ pub struct Intrinsics<'ctx> {
pub debug_trap: FunctionValue<'ctx>,
pub personality: FunctionValue<'ctx>,
pub readonly: Attribute,
pub void_ty: VoidType<'ctx>,
pub i1_ty: IntType<'ctx>,
@@ -141,22 +142,7 @@ pub struct Intrinsics<'ctx> {
pub trap_table_access_oob: BasicValueEnum<'ctx>,
// VM intrinsics.
pub memory_grow_dynamic_local: FunctionValue<'ctx>,
pub memory_grow_static_local: FunctionValue<'ctx>,
pub memory_grow_shared_local: FunctionValue<'ctx>,
pub memory_grow_dynamic_import: FunctionValue<'ctx>,
pub memory_grow_static_import: FunctionValue<'ctx>,
pub memory_grow_shared_import: FunctionValue<'ctx>,
pub memory_size_dynamic_local: FunctionValue<'ctx>,
pub memory_size_static_local: FunctionValue<'ctx>,
pub memory_size_shared_local: FunctionValue<'ctx>,
pub memory_size_dynamic_import: FunctionValue<'ctx>,
pub memory_size_static_import: FunctionValue<'ctx>,
pub memory_size_shared_import: FunctionValue<'ctx>,
pub throw_trap: FunctionValue<'ctx>,
pub throw_breakpoint: FunctionValue<'ctx>,
pub experimental_stackmap: FunctionValue<'ctx>,
@@ -258,13 +244,6 @@ impl<'ctx> Intrinsics<'ctx> {
let ret_f32_take_f32_f32 = f32_ty.fn_type(&[f32_ty_basic, f32_ty_basic], false);
let ret_f64_take_f64_f64 = f64_ty.fn_type(&[f64_ty_basic, f64_ty_basic], false);
let ret_i32_take_ctx_i32_i32 = i32_ty.fn_type(
&[ctx_ptr_ty.as_basic_type_enum(), i32_ty_basic, i32_ty_basic],
false,
);
let ret_i32_take_ctx_i32 =
i32_ty.fn_type(&[ctx_ptr_ty.as_basic_type_enum(), i32_ty_basic], false);
let ret_i1_take_i1_i1 = i1_ty.fn_type(&[i1_ty_basic, i1_ty_basic], false);
let intrinsics = Self {
ctlz_i32: module.add_function("llvm.ctlz.i32", ret_i32_take_i32_i1, None),
@@ -351,6 +330,8 @@ impl<'ctx> Intrinsics<'ctx> {
i32_ty.fn_type(&[], false),
Some(Linkage::External),
),
readonly: context
.create_enum_attribute(Attribute::get_named_enum_kind_id("readonly"), 0),
void_ty,
i1_ty,
@@ -419,67 +400,6 @@ impl<'ctx> Intrinsics<'ctx> {
.as_basic_value_enum(),
// VM intrinsics.
memory_grow_dynamic_local: module.add_function(
"vm.memory.grow.dynamic.local",
ret_i32_take_ctx_i32_i32,
None,
),
memory_grow_static_local: module.add_function(
"vm.memory.grow.static.local",
ret_i32_take_ctx_i32_i32,
None,
),
memory_grow_shared_local: module.add_function(
"vm.memory.grow.shared.local",
ret_i32_take_ctx_i32_i32,
None,
),
memory_grow_dynamic_import: module.add_function(
"vm.memory.grow.dynamic.import",
ret_i32_take_ctx_i32_i32,
None,
),
memory_grow_static_import: module.add_function(
"vm.memory.grow.static.import",
ret_i32_take_ctx_i32_i32,
None,
),
memory_grow_shared_import: module.add_function(
"vm.memory.grow.shared.import",
ret_i32_take_ctx_i32_i32,
None,
),
memory_size_dynamic_local: module.add_function(
"vm.memory.size.dynamic.local",
ret_i32_take_ctx_i32,
None,
),
memory_size_static_local: module.add_function(
"vm.memory.size.static.local",
ret_i32_take_ctx_i32,
None,
),
memory_size_shared_local: module.add_function(
"vm.memory.size.shared.local",
ret_i32_take_ctx_i32,
None,
),
memory_size_dynamic_import: module.add_function(
"vm.memory.size.dynamic.import",
ret_i32_take_ctx_i32,
None,
),
memory_size_static_import: module.add_function(
"vm.memory.size.static.import",
ret_i32_take_ctx_i32,
None,
),
memory_size_shared_import: module.add_function(
"vm.memory.size.shared.import",
ret_i32_take_ctx_i32,
None,
),
throw_trap: module.add_function(
"vm.exception.trap",
void_ty.fn_type(&[i32_ty_basic], false),
@@ -496,11 +416,6 @@ impl<'ctx> Intrinsics<'ctx> {
),
None,
),
throw_breakpoint: module.add_function(
"vm.breakpoint",
void_ty.fn_type(&[i64_ty_basic], false),
None,
),
vmfunction_import_ptr_ty: context
.struct_type(&[i8_ptr_ty_basic, i8_ptr_ty_basic], false)
@@ -539,35 +454,11 @@ impl<'ctx> Intrinsics<'ctx> {
// TODO: mark vmctx args as nofree, align 16, dereferenceable(?)
let readonly =
context.create_enum_attribute(Attribute::get_named_enum_kind_id("readonly"), 0);
intrinsics
.memory_size_dynamic_local
.add_attribute(AttributeLoc::Function, readonly);
intrinsics
.memory_size_static_local
.add_attribute(AttributeLoc::Function, readonly);
intrinsics
.memory_size_shared_local
.add_attribute(AttributeLoc::Function, readonly);
intrinsics
.memory_size_dynamic_import
.add_attribute(AttributeLoc::Function, readonly);
intrinsics
.memory_size_static_import
.add_attribute(AttributeLoc::Function, readonly);
intrinsics
.memory_size_shared_import
.add_attribute(AttributeLoc::Function, readonly);
let noreturn =
context.create_enum_attribute(Attribute::get_named_enum_kind_id("noreturn"), 0);
intrinsics
.throw_trap
.add_attribute(AttributeLoc::Function, noreturn);
intrinsics
.throw_breakpoint
.add_attribute(AttributeLoc::Function, noreturn);
intrinsics
}