Subzero: Fix over-aggressive bool folding.

src/IceIntrinsics.cpp

 //===- subzero/src/IceIntrinsics.cpp - Functions related to intrinsics ----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 13 matching lines @@
 
 #include <utility>
 
 namespace Ice {
 
 static_assert(sizeof(Intrinsics::IntrinsicInfo) == 4,
               "Unexpected sizeof(IntrinsicInfo)");
 
 namespace {
 
-#define INTRIN(ID, SE, RT)                                                     \
-  { Intrinsics::ID, Intrinsics::SE, Intrinsics::RT }
+#define INTRIN(ID, SE, RT, MW)                                                 \
+  { Intrinsics::ID, Intrinsics::SE, Intrinsics::RT, Intrinsics::MW }
 
 // Build list of intrinsics with their attributes and expected prototypes. List
 // is sorted alphabetically.
 const struct IceIntrinsicsEntry_ {
   Intrinsics::FullIntrinsicInfo Info;
   const char *IntrinsicName;
 } IceIntrinsicsTable[] = {
 
-#define AtomicCmpxchgInit(Overload, NameSuffix)                                \
-  {                                                                            \
-    {                                                                          \
-      INTRIN(AtomicCmpxchg, SideEffects_T, ReturnsTwice_F), {Overload,         \
-                                                             IceType_i32,      \
-                                                             Overload,         \
-                                                             Overload,         \
-                                                             IceType_i32,      \
-                                                             IceType_i32},     \
-          6                                                                    \
-    }                                                                          \
-    , "llvm.nacl.atomic.cmpxchg." NameSuffix                                   \
+#define AtomicCmpxchgInit(Overload, NameSuffix)                                  \
+  {                                                                              \
+    {                                                                            \
+      INTRIN(AtomicCmpxchg, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),       \
+          {Overload, IceType_i32, Overload, Overload, IceType_i32, IceType_i32}, \
+          6                                                                      \
+    }                                                                            \
+    , "llvm.nacl.atomic.cmpxchg." NameSuffix                                     \
   }
     AtomicCmpxchgInit(IceType_i8, "i8"),
     AtomicCmpxchgInit(IceType_i16, "i16"),
     AtomicCmpxchgInit(IceType_i32, "i32"),
     AtomicCmpxchgInit(IceType_i64, "i64"),
 #undef AtomicCmpxchgInit
 
-    {{INTRIN(AtomicFence, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(AtomicFence, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
       {IceType_void, IceType_i32},
       2},
      "llvm.nacl.atomic.fence"},
-    {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
+    {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
+      {IceType_void},
+      1},
      "llvm.nacl.atomic.fence.all"},
-    {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F),
+    {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),
       {IceType_i1, IceType_i32, IceType_i32},
       3},
      "llvm.nacl.atomic.is.lock.free"},
 
 #define AtomicLoadInit(Overload, NameSuffix)                                   \
   {                                                                            \
     {                                                                          \
-      INTRIN(AtomicLoad, SideEffects_T, ReturnsTwice_F),                       \
+      INTRIN(AtomicLoad, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),        \
           {Overload, IceType_i32, IceType_i32}, 3                              \
     }                                                                          \
     , "llvm.nacl.atomic.load." NameSuffix                                      \
   }
     AtomicLoadInit(IceType_i8, "i8"),
     AtomicLoadInit(IceType_i16, "i16"),
     AtomicLoadInit(IceType_i32, "i32"),
     AtomicLoadInit(IceType_i64, "i64"),
 #undef AtomicLoadInit
 
 #define AtomicRMWInit(Overload, NameSuffix)                                    \
   {                                                                            \
     {                                                                          \
-      INTRIN(AtomicRMW, SideEffects_T, ReturnsTwice_F)                         \
+      INTRIN(AtomicRMW, SideEffects_T, ReturnsTwice_F, MemoryWrite_T)          \
       , {Overload, IceType_i32, IceType_i32, Overload, IceType_i32}, 5         \
     }                                                                          \
     , "llvm.nacl.atomic.rmw." NameSuffix                                       \
   }
     AtomicRMWInit(IceType_i8, "i8"),
     AtomicRMWInit(IceType_i16, "i16"),
     AtomicRMWInit(IceType_i32, "i32"),
     AtomicRMWInit(IceType_i64, "i64"),
 #undef AtomicRMWInit
 
 #define AtomicStoreInit(Overload, NameSuffix)                                  \
   {                                                                            \
     {                                                                          \
-      INTRIN(AtomicStore, SideEffects_T, ReturnsTwice_F)                       \
+      INTRIN(AtomicStore, SideEffects_T, ReturnsTwice_F, MemoryWrite_T)        \
       , {IceType_void, Overload, IceType_i32, IceType_i32}, 4                  \
     }                                                                          \
     , "llvm.nacl.atomic.store." NameSuffix                                     \
   }
     AtomicStoreInit(IceType_i8, "i8"),
     AtomicStoreInit(IceType_i16, "i16"),
     AtomicStoreInit(IceType_i32, "i32"),
     AtomicStoreInit(IceType_i64, "i64"),
 #undef AtomicStoreInit
 
 #define BswapInit(Overload, NameSuffix)                                        \
   {                                                                            \
     {                                                                          \
-      INTRIN(Bswap, SideEffects_F, ReturnsTwice_F)                             \
+      INTRIN(Bswap, SideEffects_F, ReturnsTwice_F, MemoryWrite_F)              \
       , {Overload, Overload}, 2                                                \
     }                                                                          \
     , "llvm.bswap." NameSuffix                                                 \
   }
     BswapInit(IceType_i16, "i16"),
     BswapInit(IceType_i32, "i32"),
     BswapInit(IceType_i64, "i64"),
 #undef BswapInit
 
 #define CtlzInit(Overload, NameSuffix)                                         \
   {                                                                            \
     {                                                                          \
-      INTRIN(Ctlz, SideEffects_F, ReturnsTwice_F)                              \
+      INTRIN(Ctlz, SideEffects_F, ReturnsTwice_F, MemoryWrite_F)               \
       , {Overload, Overload, IceType_i1}, 3                                    \
     }                                                                          \
     , "llvm.ctlz." NameSuffix                                                  \
   }
     CtlzInit(IceType_i32, "i32"),
     CtlzInit(IceType_i64, "i64"),
 #undef CtlzInit
 
 #define CtpopInit(Overload, NameSuffix)                                        \
   {                                                                            \
     {                                                                          \
-      INTRIN(Ctpop, SideEffects_F, ReturnsTwice_F)                             \
+      INTRIN(Ctpop, SideEffects_F, ReturnsTwice_F, MemoryWrite_F)              \
       , {Overload, Overload}, 2                                                \
     }                                                                          \
     , "llvm.ctpop." NameSuffix                                                 \
   }
     CtpopInit(IceType_i32, "i32"),
     CtpopInit(IceType_i64, "i64"),
 #undef CtpopInit
 
 #define CttzInit(Overload, NameSuffix)                                         \
   {                                                                            \
     {                                                                          \
-      INTRIN(Cttz, SideEffects_F, ReturnsTwice_F)                              \
+      INTRIN(Cttz, SideEffects_F, ReturnsTwice_F, MemoryWrite_F)               \
       , {Overload, Overload, IceType_i1}, 3                                    \
     }                                                                          \
     , "llvm.cttz." NameSuffix                                                  \
   }
     CttzInit(IceType_i32, "i32"),
     CttzInit(IceType_i64, "i64"),
 #undef CttzInit
 
 #define FabsInit(Overload, NameSuffix)                                         \
   {                                                                            \
-    { INTRIN(Fabs, SideEffects_F, ReturnsTwice_F), {Overload, Overload}, 2 }   \
+    {                                                                          \
+      INTRIN(Fabs, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),              \
+          {Overload, Overload}, 2                                              \
+    }                                                                          \
     , "llvm.fabs." NameSuffix                                                  \
   }
     FabsInit(IceType_f32, "f32"),
     FabsInit(IceType_f64, "f64"),
     FabsInit(IceType_v4f32, "v4f32"),
 #undef FabsInit
 
-    {{INTRIN(Longjmp, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(Longjmp, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
       {IceType_void, IceType_i32, IceType_i32},
       3},
      "llvm.nacl.longjmp"},
-    {{INTRIN(Memcpy, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(Memcpy, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
       {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
        IceType_i1},
       6},
      "llvm.memcpy.p0i8.p0i8.i32"},
-    {{INTRIN(Memmove, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(Memmove, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
       {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
        IceType_i1},
       6},
      "llvm.memmove.p0i8.p0i8.i32"},
-    {{INTRIN(Memset, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(Memset, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
       {IceType_void, IceType_i32, IceType_i8, IceType_i32, IceType_i32,
        IceType_i1},
       6},
      "llvm.memset.p0i8.i32"},
-    {{INTRIN(NaClReadTP, SideEffects_F, ReturnsTwice_F), {IceType_i32}, 1},
+    {{INTRIN(NaClReadTP, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),
+      {IceType_i32},
+      1},
      "llvm.nacl.read.tp"},
-    {{INTRIN(Setjmp, SideEffects_T, ReturnsTwice_T),
+    {{INTRIN(Setjmp, SideEffects_T, ReturnsTwice_T, MemoryWrite_T),
       {IceType_i32, IceType_i32},
       2},
      "llvm.nacl.setjmp"},
 
 #define SqrtInit(Overload, NameSuffix)                                         \
   {                                                                            \
-    { INTRIN(Sqrt, SideEffects_F, ReturnsTwice_F), {Overload, Overload}, 2 }   \
+    {                                                                          \
+      INTRIN(Sqrt, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),              \
+          {Overload, Overload}, 2                                              \
+    }                                                                          \
     , "llvm.sqrt." NameSuffix                                                  \
   }
     SqrtInit(IceType_f32, "f32"),
     SqrtInit(IceType_f64, "f64"),
 #undef SqrtInit
 
-    {{INTRIN(Stacksave, SideEffects_T, ReturnsTwice_F), {IceType_i32}, 1},
+    {{INTRIN(Stacksave, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
+      {IceType_i32},
+      1},
      "llvm.stacksave"},
-    {{INTRIN(Stackrestore, SideEffects_T, ReturnsTwice_F),
+    {{INTRIN(Stackrestore, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
       {IceType_void, IceType_i32},
       2},
      "llvm.stackrestore"},
-    {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
+    {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
+      {IceType_void},
+      1},
      "llvm.trap"}};
 const size_t IceIntrinsicsTableSize = llvm::array_lengthof(IceIntrinsicsTable);
 
 #undef INTRIN
 
 } // end of anonymous namespace
 
 Intrinsics::Intrinsics(GlobalContext *Ctx) {
   for (size_t I = 0; I < IceIntrinsicsTableSize; ++I) {
     const struct IceIntrinsicsEntry_ &Entry = IceIntrinsicsTable[I];
@@ skipping 110 matching lines @@
   return Intrinsics::IsValidCall;
 }
 
 Type Intrinsics::FullIntrinsicInfo::getArgType(SizeT Index) const {
   assert(NumTypes > 1);
   assert(Index + 1 < NumTypes);
   return Signature[Index + 1];
 }
 
 } // end of namespace Ice