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

Merge pull request #74 from wasmerio/llvm-needs-more-volatile

Browse Source 
Mark atomicrmw and cmpxchg volatile when appropriate.
This commit is contained in:
nlewycky
2020-05-28 17:25:06 -07:00
committed by GitHub
parent acfb081d6c d597a97aa1
commit c0dac31be2
3 changed files with 243 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.lock generated
View File

@@ -702,7 +702,7 @@ dependencies = [
[[package]] [[package]]
name = "inkwell" name = "inkwell"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/theDan64/inkwell?rev=1bfecc0a095d7ffdfa20a64630864f0297349508#1bfecc0a095d7ffdfa20a64630864f0297349508" source = "git+https://github.com/theDan64/inkwell?rev=fdf895777e937c974204e879cf1102cf7a727c42#fdf895777e937c974204e879cf1102cf7a727c42"
dependencies = [ dependencies = [
"either", "either",
"inkwell_internals", "inkwell_internals",
@@ -715,8 +715,8 @@ dependencies = [
[[package]] [[package]]
name = "inkwell_internals" name = "inkwell_internals"
version = "0.1.0" version = "0.2.0"
source = "git+https://github.com/theDan64/inkwell?rev=1bfecc0a095d7ffdfa20a64630864f0297349508#1bfecc0a095d7ffdfa20a64630864f0297349508" source = "git+https://github.com/theDan64/inkwell?rev=fdf895777e937c974204e879cf1102cf7a727c42#fdf895777e937c974204e879cf1102cf7a727c42"
dependencies = [ dependencies = [
"proc-macro2", "proc-macro2",
"quote", "quote",

4
lib/compiler-llvm/Cargo.toml
View File

@@ -24,14 +24,14 @@ rayon = "1.3"
[target.'cfg(target_arch = "x86_64")'.dependencies.inkwell] [target.'cfg(target_arch = "x86_64")'.dependencies.inkwell]
#version = "0.1.0-llvm8sample" #version = "0.1.0-llvm8sample"
git = "https://github.com/theDan64/inkwell" git = "https://github.com/theDan64/inkwell"
rev = "1bfecc0a095d7ffdfa20a64630864f0297349508" rev = "fdf895777e937c974204e879cf1102cf7a727c42"
default-features = false default-features = false
features = ["llvm10-0", "target-x86"] features = ["llvm10-0", "target-x86"]
[target.'cfg(target_arch = "aarch64")'.dependencies.inkwell] [target.'cfg(target_arch = "aarch64")'.dependencies.inkwell]
#version = "0.1.0-llvm8sample" #version = "0.1.0-llvm8sample"
git = "https://github.com/theDan64/inkwell" git = "https://github.com/theDan64/inkwell"
rev = "1bfecc0a095d7ffdfa20a64630864f0297349508" rev = "fdf895777e937c974204e879cf1102cf7a727c42"
default-features = false default-features = false
features = ["llvm10-0", "target-aarch64"] features = ["llvm10-0", "target-aarch64"]

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

@@ -16,8 +16,8 @@ use inkwell::{
targets::FileType, targets::FileType,
types::{BasicType, BasicTypeEnum, FloatMathType, IntType, PointerType, VectorType}, types::{BasicType, BasicTypeEnum, FloatMathType, IntType, PointerType, VectorType},
values::{ values::{
BasicValue, BasicValueEnum, FloatValue, FunctionValue, InstructionValue, IntValue, BasicValue, BasicValueEnum, FloatValue, FunctionValue, InstructionOpcode, InstructionValue,
PhiValue, PointerValue, VectorValue, IntValue, PhiValue, PointerValue, VectorValue,
}, },
AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate, AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate,
}; };
@@ -937,7 +937,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
alignment: u32, alignment: u32,
memaccess: InstructionValue<'ctx>, memaccess: InstructionValue<'ctx>,
) -> Result<(), CompileError> { ) -> Result<(), CompileError> {
memaccess.set_alignment(alignment).unwrap(); match memaccess.get_opcode() {
InstructionOpcode::Load | InstructionOpcode::Store => {
memaccess.set_alignment(alignment).unwrap();
}
_ => {}
};
self.mark_memaccess_nodelete(memory_index, memaccess)?; self.mark_memaccess_nodelete(memory_index, memaccess)?;
tbaa_label( tbaa_label(
&self.module, &self.module,
@@ -6573,12 +6578,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6608,12 +6613,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6643,12 +6648,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6675,12 +6680,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8SubU { ref memarg } => { Operator::I32AtomicRmw8SubU { ref memarg } => {
@@ -6707,12 +6712,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -6742,12 +6747,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -6774,12 +6779,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I64AtomicRmw8SubU { ref memarg } => { Operator::I64AtomicRmw8SubU { ref memarg } => {
@@ -6806,12 +6811,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6841,12 +6846,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6876,12 +6881,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -6908,12 +6913,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8AndU { ref memarg } => { Operator::I32AtomicRmw8AndU { ref memarg } => {
@@ -6940,12 +6945,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -6975,12 +6980,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7007,12 +7012,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I64AtomicRmw8AndU { ref memarg } => { Operator::I64AtomicRmw8AndU { ref memarg } => {
@@ -7039,12 +7044,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7074,12 +7079,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7109,12 +7114,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7141,12 +7146,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8OrU { ref memarg } => { Operator::I32AtomicRmw8OrU { ref memarg } => {
@@ -7173,12 +7178,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7208,12 +7213,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7240,12 +7245,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7275,12 +7280,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7310,12 +7315,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7345,12 +7350,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7377,12 +7382,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8XorU { ref memarg } => { Operator::I32AtomicRmw8XorU { ref memarg } => {
@@ -7409,12 +7414,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7444,12 +7449,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7476,12 +7481,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I64AtomicRmw8XorU { ref memarg } => { Operator::I64AtomicRmw8XorU { ref memarg } => {
@@ -7508,12 +7513,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7543,12 +7548,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7578,12 +7583,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7610,12 +7615,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8XchgU { ref memarg } => { Operator::I32AtomicRmw8XchgU { ref memarg } => {
@@ -7642,12 +7647,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7677,12 +7682,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i32_ty, ""); .build_int_z_extend(old, self.intrinsics.i32_ty, "");
@@ -7709,12 +7714,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I64AtomicRmw8XchgU { ref memarg } => { Operator::I64AtomicRmw8XchgU { ref memarg } => {
@@ -7741,12 +7746,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7776,12 +7781,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7811,12 +7816,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_int_z_extend(old, self.intrinsics.i64_ty, ""); .build_int_z_extend(old, self.intrinsics.i64_ty, "");
@@ -7843,12 +7848,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
self.state.push1(old); self.state.push1(old);
} }
Operator::I32AtomicRmw8CmpxchgU { ref memarg } => { Operator::I32AtomicRmw8CmpxchgU { ref memarg } => {
@@ -7882,12 +7887,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_extract_value(old, 0, "") .build_extract_value(old, 0, "")
@@ -7929,12 +7934,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_extract_value(old, 0, "") .build_extract_value(old, 0, "")
@@ -7970,12 +7975,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self.builder.build_extract_value(old, 0, "").unwrap(); let old = self.builder.build_extract_value(old, 0, "").unwrap();
self.state.push1(old); self.state.push1(old);
} }
@@ -8010,12 +8015,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_extract_value(old, 0, "") .build_extract_value(old, 0, "")
@@ -8057,12 +8062,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_extract_value(old, 0, "") .build_extract_value(old, 0, "")
@@ -8104,12 +8109,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self let old = self
.builder .builder
.build_extract_value(old, 0, "") .build_extract_value(old, 0, "")
@@ -8145,12 +8150,12 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
AtomicOrdering::SequentiallyConsistent, AtomicOrdering::SequentiallyConsistent,
) )
.unwrap(); .unwrap();
tbaa_label( self.annotate_user_memaccess(
&self.module, memory_index,
self.intrinsics, memarg,
format!("memory {}", memory_index.as_u32()), 0,
old.as_instruction_value().unwrap(), old.as_instruction_value().unwrap(),
); )?;
let old = self.builder.build_extract_value(old, 0, "").unwrap(); let old = self.builder.build_extract_value(old, 0, "").unwrap();
self.state.push1(old); self.state.push1(old);
} }