Mark setjmp as "returns twice" and turn off SimpleCoalescing when called.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Intrinsics utilities for matching and
 // then dispatching by name.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceIntrinsics.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 
 #include <utility>
 
 namespace Ice {
 
 namespace {
 
+// 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)                                \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::AtomicCmpxchg, true },                                     \
+      { Intrinsics::AtomicCmpxchg, true, false },                              \

[Jim Stichnoth, 2014/09/11 20:12:05]

Maybe this CL isn't the right place for this, but it's hard to remember what
attributes and in what order the "true, false" represent, and it's only going to
get worse. :)

Maybe the way to do this is to use symbolic constants like SideEffects_T,
SideEffects_F, ReturnsTwice_T, ReturnsTwice_F.  Define them as values from
separate enums:

enum SideEffects { SideEffects_F=0, SideEffects_T=1 };
enum ReturnTwice { ReturnTwice_F=0, ReturnTwice_T=1 };

Change the definition of IntrinsicInfo:

  struct IntrinsicInfo {
    IntrinsicID ID : 30;
    enum SideEffects HasSideEffects : 1;
    enum ReturnTwice ReturnsTwice : 1;
  };


Then have an initialization macro:
#define INTRIN(ID, SE, RT) { Intrinsics::ID, SideEffects::SE, ReturnTwice::RT }

Then the initializers look like:

INTRIN(AtomicFence, SideEffects_T, ReturnTwice_F),
INTRIN(AtomicIsLockFree, SideEffects_F, ReturnTwice_F),
...

And if you make a mistake:
INTRIN(AtomicFence, ReturnTwice_F, SideEffects_T),
the compiler will give an error.

Thanks to JF for this approach.  JF also points out that C++ only guarantees
proper packing of bitfields in a struct when the bitfields are the same type, so
they should really be declared as uint32_t and then accessor functions do the
type casting, and you can static_assert that sizeof(IntrinsicInfo)==4.

[jvoung (off chromium), 2014/09/11 21:57:18]

Nice! I was worried about losing track of the true/false as well, and the C99 {
.field = <xxx> } isn't allowed in C++. This works nicely.

However, I couldn't do: #define INTRIN(ID, SE, RT) { ... SideEffects::SE ... }

src/IceIntrinsics.cpp:31:46: error: ‘SideEffects’ has not been declared
 #define INTRIN(ID, SE, RT) { Intrinsics::ID, SideEffects::SE, Intrinsics::RT }
                                              ^
(anyway, that error is silly because I declared the enum within the Intrinsics
class). However, the attempt that could actually refer to SideEffects

#define INTRIN(ID, SE, RT) { ... Intrinsics::SideEffects::SE ... }

also doesn't work:

src/IceIntrinsics.cpp:31:58: error: ‘Ice::Intrinsics::SideEffects’ is not a
class or namespace
 #define INTRIN(ID, SE, RT) { Intrinsics::ID, Intrinsics::SideEffects::SE,
Intrinsics::RT }

So I had to just go with: #define INTRIN(ID, SE, RT) { ... Intrinsics::SE ... }

which would leave only the type-checking of the field's type (so I can't change
it to uint32_t?). Added the STATIC_ASSERT though.

[Jim Stichnoth, 2014/09/11 22:26:26]

Oh, right.  I forgot to relay JF's other suggestion.  Change IntrinsicInfo to be
a class, make the (uint32_t) fields private, use a constructor with various enum
type arguments to make the type checking work out, cast them to uint32_t in the
constructor, and add accessor functions that cast from uint32_t to the proper
enum type.

[jvoung (off chromium), 2014/09/11 22:58:57]

I thought about using a class + ctor, but doesn't that make this non-POD and add
a static initializer?

It looks like c++11 does allow the Intrinsics::SideEffects::SE, so I could
switch to that when we start compiling with c++11.

       { Overload, IceType_i32, Overload, Overload, IceType_i32, IceType_i32 }, \
       6                                                                        \
     }                                                                          \
     , "nacl.atomic.cmpxchg." NameSuffix                                        \
   }
     AtomicCmpxchgInit(IceType_i8, "i8"),
     AtomicCmpxchgInit(IceType_i16, "i16"),
     AtomicCmpxchgInit(IceType_i32, "i32"),
     AtomicCmpxchgInit(IceType_i64, "i64"),
 #undef AtomicCmpxchgInit
-    { { { Intrinsics::AtomicFence, true }, { IceType_void, IceType_i32 }, 2 },
+
+    { { { Intrinsics::AtomicFence, true, false }, { IceType_void, IceType_i32 },
+        2},
       "nacl.atomic.fence" },
-    { { { Intrinsics::AtomicFenceAll, true }, { IceType_void }, 1 },
+    { { { Intrinsics::AtomicFenceAll, true, false }, { IceType_void }, 1 },
       "nacl.atomic.fence.all" },
-    { { { Intrinsics::AtomicIsLockFree, false },
+    { { { Intrinsics::AtomicIsLockFree, false, false },
         { IceType_i1, IceType_i32, IceType_i32 }, 3 },
       "nacl.atomic.is.lock.free" },
 
 #define AtomicLoadInit(Overload, NameSuffix)                                   \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::AtomicLoad, true }                                         \
+      { Intrinsics::AtomicLoad, true, false }                                  \
       , { Overload, IceType_i32, IceType_i32 }, 3                              \
     }                                                                          \
     , "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)                                    \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::AtomicRMW, true }                                          \
+      { Intrinsics::AtomicRMW, true, false }                                   \
       , { Overload, IceType_i32, IceType_i32, Overload, IceType_i32 }, 5       \
     }                                                                          \
     , "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)                                  \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::AtomicStore, true }                                        \
+      { Intrinsics::AtomicStore, true, false }                                 \
       , { IceType_void, Overload, IceType_i32, IceType_i32 }, 4                \
     }                                                                          \
     , "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)                                        \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::Bswap, false }                                             \
+      { Intrinsics::Bswap, false, false }                                      \
       , { Overload, Overload }, 2                                              \
     }                                                                          \
     , "bswap." NameSuffix                                                      \
   }
     BswapInit(IceType_i16, "i16"),
     BswapInit(IceType_i32, "i32"),
     BswapInit(IceType_i64, "i64"),
 #undef BswapInit
 
 #define CtlzInit(Overload, NameSuffix)                                         \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::Ctlz, false }                                              \
+      { Intrinsics::Ctlz, false, false }                                       \
       , { Overload, Overload, IceType_i1 }, 3                                  \
     }                                                                          \
     , "ctlz." NameSuffix                                                       \
   }
     CtlzInit(IceType_i32, "i32"),
     CtlzInit(IceType_i64, "i64"),
 #undef CtlzInit
 
 #define CtpopInit(Overload, NameSuffix)                                        \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::Ctpop, false }                                             \
+      { Intrinsics::Ctpop, false, false }                                      \
       , { Overload, Overload }, 2                                              \
     }                                                                          \
     , "ctpop." NameSuffix                                                      \
   }
     CtpopInit(IceType_i32, "i32"),
     CtpopInit(IceType_i64, "i64"),
 #undef CtpopInit
 
 #define CttzInit(Overload, NameSuffix)                                         \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::Cttz, false }                                              \
+      { Intrinsics::Cttz, false, false }                                       \
       , { Overload, Overload, IceType_i1 }, 3                                  \
     }                                                                          \
     , "cttz." NameSuffix                                                       \
   }
     CttzInit(IceType_i32, "i32"),
     CttzInit(IceType_i64, "i64"),
 #undef CttzInit
-    { { { Intrinsics::Longjmp, true },
+
+    { { { Intrinsics::Longjmp, true, false },
         { IceType_void, IceType_i32, IceType_i32 }, 3 },
       "nacl.longjmp" },
-    { { { Intrinsics::Memcpy, true }, { IceType_void, IceType_i32, IceType_i32,
-                                        IceType_i32,  IceType_i32, IceType_i1 },
+    { { { Intrinsics::Memcpy, true, false },
+        { IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
+          IceType_i1},
         6 },
       "memcpy.p0i8.p0i8.i32" },
-    { { { Intrinsics::Memmove, true },
-        { IceType_void, IceType_i32, IceType_i32,
-          IceType_i32,  IceType_i32, IceType_i1 },
+    { { { Intrinsics::Memmove, true, false },
+        { IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
+          IceType_i1 },
         6 },
       "memmove.p0i8.p0i8.i32" },
-    { { { Intrinsics::Memset, true }, { IceType_void, IceType_i32, IceType_i8,
-                                        IceType_i32,  IceType_i32, IceType_i1 },
+    { { { Intrinsics::Memset, true, false },
+        { IceType_void, IceType_i32, IceType_i8, IceType_i32, IceType_i32,
+          IceType_i1 },
         6 },
       "memset.p0i8.i32" },
-    { { { Intrinsics::NaClReadTP, false }, { IceType_i32 }, 1 },
+    { { { Intrinsics::NaClReadTP, false, false }, { IceType_i32 }, 1 },
       "nacl.read.tp" },
-    { { { Intrinsics::Setjmp, true }, { IceType_i32, IceType_i32 }, 2 },
+    { { { Intrinsics::Setjmp, true, true }, { IceType_i32, IceType_i32 }, 2 },
       "nacl.setjmp" },
 
 #define SqrtInit(Overload, NameSuffix)                                         \
   {                                                                            \
     {                                                                          \
-      { Intrinsics::Sqrt, false }                                              \
+      { Intrinsics::Sqrt, false, false }                                       \
       , { Overload, Overload }, 2                                              \
     }                                                                          \
     , "sqrt." NameSuffix                                                       \
   }
     SqrtInit(IceType_f32, "f32"),
     SqrtInit(IceType_f64, "f64"),
 #undef SqrtInit
-    { { { Intrinsics::Stacksave, true }, { IceType_i32 }, 1 }, "stacksave" },
-    { { { Intrinsics::Stackrestore, true }, { IceType_void, IceType_i32 }, 2 },
+
+    { { { Intrinsics::Stacksave, true, false }, { IceType_i32 }, 1 },
+      "stacksave" },
+    { { { Intrinsics::Stackrestore, true, false },
+        { IceType_void, IceType_i32 },
+        2 },
       "stackrestore" },
-    { { { Intrinsics::Trap, true }, { IceType_void }, 1 }, "trap" }
-  };
+    { { { Intrinsics::Trap, true, false }, { IceType_void }, 1 }, "trap" }
+};
 const size_t IceIntrinsicsTableSize = llvm::array_lengthof(IceIntrinsicsTable);
 
 } // end of anonymous namespace
 
 Intrinsics::Intrinsics() {
   for (size_t I = 0; I < IceIntrinsicsTableSize; ++I) {
     const struct IceIntrinsicsEntry_ &Entry = IceIntrinsicsTable[I];
     assert(Entry.Info.NumTypes <= kMaxIntrinsicParameters);
     map.insert(std::make_pair(IceString(Entry.IntrinsicName), Entry.Info));
   }
 }
 
 Intrinsics::~Intrinsics() {}
 
 const Intrinsics::FullIntrinsicInfo *
 Intrinsics::find(const IceString &Name) const {
   IntrinsicMap::const_iterator it = map.find(Name);
   if (it == map.end())
     return NULL;
   return &it->second;
 }
 
 bool Intrinsics::VerifyMemoryOrder(uint64_t Order) {
   // There is only one memory ordering for atomics allowed right now.
   return Order == Intrinsics::MemoryOrderSequentiallyConsistent;
 }
 
 } // end of namespace Ice