Concurrency support for PNaCl ABI

test/Transforms/NaCl/replace-ptrs-with-ints.ll

 ; RUN: opt %s -replace-ptrs-with-ints -S | FileCheck %s
 
 target datalayout = "p:32:32:32"
 
 
 %struct = type { i32, i32 }
 
 declare %struct* @addr_taken_func(%struct*)
 
 @addr_of_func = global %struct* (%struct*)* @addr_taken_func
@@ skipping 227 matching lines @@
 
 define void @store_ptr(i8** %ptr, i8* %val) {
   store i8* %val, i8** %ptr
   ret void
 }
 ; CHECK: define void @store_ptr(i32 %ptr, i32 %val) {
 ; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
 ; CHECK-NEXT: store i32 %val, i32* %ptr.asptr
 
 
-define i8 @load_attrs(i8* %ptr) {

[Mark Seaborn, 2013/06/26 14:33:41]

Please leave this in.  ReplacePtrsWithInts still handles these cases OK, and it
might as well stay tested.

[JF, 2013/06/26 15:52:29]

Done.

-  %x = load atomic volatile i8* %ptr seq_cst, align 128
-  ret i8 %x
-}
-; CHECK: define i8 @load_attrs(i32 %ptr) {
-; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
-; CHECK-NEXT: %x = load atomic volatile i8* %ptr.asptr seq_cst, align 128
-
-define void @store_attrs(i8* %ptr, i8 %val) {
-  store atomic volatile i8 %val, i8* %ptr singlethread release, align 256
-  ret void
-}
-; CHECK: define void @store_attrs(i32 %ptr, i8 %val) {
-; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
-; CHECK-NEXT: store atomic volatile i8 %val, i8* %ptr.asptr singlethread release, align 256
-
-
-define i32 @cmpxchg(i32* %ptr, i32 %a, i32 %b) {
-  %r = cmpxchg i32* %ptr, i32 %a, i32 %b seq_cst
-  ret i32 %r
-}
-; CHECK: define i32 @cmpxchg(i32 %ptr, i32 %a, i32 %b) {
-; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
-; CHECK-NEXT: %r = cmpxchg i32* %ptr.asptr, i32 %a, i32 %b seq_cst
-
-define i32 @atomicrmw(i32* %ptr, i32 %x) {
-  %r = atomicrmw add i32* %ptr, i32 %x seq_cst
-  ret i32 %r
-}
-; CHECK: define i32 @atomicrmw(i32 %ptr, i32 %x) {
-; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
-; CHECK-NEXT: %r = atomicrmw add i32* %ptr.asptr, i32 %x seq_cst
-
-
 define i8* @indirect_call(i8* (i8*)* %func, i8* %arg) {
   %result = call i8* %func(i8* %arg)
   ret i8* %result
 }
 ; CHECK: define i32 @indirect_call(i32 %func, i32 %arg) {
 ; CHECK-NEXT: %func.asptr = inttoptr i32 %func to i32 (i32)*
 ; CHECK-NEXT: %result = call i32 %func.asptr(i32 %arg)
 ; CHECK-NEXT: ret i32 %result
 
 
@@ skipping 338 matching lines @@
   %bc = bitcast i32* @typeid to i8*
   call i32 @llvm.eh.typeid.for(i8* %bc)
   ret void
 }
 ; CHECK: define void @typeid_for() {
 ; CHECK-NEXT: %typeid.bc = bitcast i32* @typeid to i8*
 ; CHECK-NEXT: call i32 @llvm.eh.typeid.for(i8* %typeid.bc)
 
 
 ; CHECK: attributes {{.*}}[[NOUNWIND]] = { nounwind }