Allow use of fixed width integer types in builtin definitions

[edward-jones]

Summary

This makes it possible to specify a bit width after the 'i' integer type specifier when defining builtins. The bswap and bitreverse builtins have been updated so that their definitions use fixed-width types instead of short, int and long, so that they work on targets where int != 32-bits and long != 64 bits.

include/clang/Basic/Builtins.def

 // builtin, and results in a clang::builtin::BIXX enum value for XX.
 
 // The second value provided to the macro specifies the type of the function
 // (result value, then each argument) as follows:
 //  v -> void
 //  b -> boolean
 //  c -> char
 //  s -> short
-//  i -> int
+//  i -> int, optionally followed by the bit width of the integer type
 //  h -> half
 //  f -> float
 //  d -> double
 //  z -> size_t
 //  w -> wchar_t
 //  F -> constant CFString
 //  G -> id
 //  H -> SEL
 //  M -> struct objc_super
 //  a -> __builtin_va_list
 //  A -> "reference" to __builtin_va_list
 //  V -> Vector, followed by the number of elements and the base type.
 //  E -> ext_vector, followed by the number of elements and the base type.
 //  X -> _Complex, followed by the base type.
 //  Y -> ptrdiff_t
 //  P -> FILE
 //  J -> jmp_buf
 //  SJ -> sigjmp_buf
 //  K -> ucontext_t
 //  p -> pid_t
 //  . -> "...".  This may only occur at the end of the function list.
 //
-// Types may be prefixed with the following modifiers:
+// Types may be prefixed with a number of modifiers. Modifiers which affect
+// the width of the integer type cannot be used if the integer is specified
+// as a fixed-width type.
 //  L   -> long (e.g. Li for 'long int')
 //  LL  -> long long
 //  LLL -> __int128_t (e.g. LLLi)
 //  W   -> int64_t
 //  S   -> signed
 //  U   -> unsigned
 //  I   -> Required to constant fold to an integer constant expression.
 //

 BUILTIN(__builtin_ffsll, "iLLi", "Fnc")
 BUILTIN(__builtin_parity  , "iUi"  , "nc")
 BUILTIN(__builtin_parityl , "iULi" , "nc")
 BUILTIN(__builtin_parityll, "iULLi", "nc")
 BUILTIN(__builtin_popcount  , "iUi"  , "nc")
 BUILTIN(__builtin_popcountl , "iULi" , "nc")
 BUILTIN(__builtin_popcountll, "iULLi", "nc")
 
-// FIXME: These type signatures are not correct for targets with int != 32-bits
-// or with ULL != 64-bits.
-BUILTIN(__builtin_bswap16, "UsUs", "nc")
-BUILTIN(__builtin_bswap32, "UiUi", "nc")
-BUILTIN(__builtin_bswap64, "ULLiULLi", "nc")
-
-BUILTIN(__builtin_bitreverse8, "UcUc", "nc")
-BUILTIN(__builtin_bitreverse16, "UsUs", "nc")
-BUILTIN(__builtin_bitreverse32, "UiUi", "nc")
-BUILTIN(__builtin_bitreverse64, "ULLiULLi", "nc")
+BUILTIN(__builtin_bswap16, "Ui16Ui16", "nc")
+BUILTIN(__builtin_bswap32, "Ui32Ui32", "nc")
+BUILTIN(__builtin_bswap64, "Ui64Ui64", "nc")
+
+BUILTIN(__builtin_bitreverse8,  "Ui8Ui8", "nc")
+BUILTIN(__builtin_bitreverse16, "Ui16Ui16", "nc")
+BUILTIN(__builtin_bitreverse32, "Ui32Ui32", "nc")
+BUILTIN(__builtin_bitreverse64, "Ui64Ui64", "nc")
 
 // Random GCC builtins
 BUILTIN(__builtin_constant_p, "i.", "nctu")
 BUILTIN(__builtin_classify_type, "i.", "nctu")
 BUILTIN(__builtin___CFStringMakeConstantString, "FC*cC*", "nc")
 BUILTIN(__builtin___NSStringMakeConstantString, "FC*cC*", "nc")
 BUILTIN(__builtin_va_start, "vA.", "nt")
 BUILTIN(__builtin_va_end, "vA", "n")

lib/AST/ASTContext.cpp

case 'd':
     break;
   case 's':
     assert(HowLong == 0 && "Bad modifiers used with 's'!");
     if (Unsigned)
       Type = Context.UnsignedShortTy;
     else
       Type = Context.ShortTy;
     break;
-  case 'i':
+  case 'i': {
+    char *End;
+    unsigned BitWidth = strtoul(Str, &End, 10);
+    if (End != Str) {
+      // Optional fixed width modifier
+      Str = End;
+      assert(HowLong == 0 && "Bad modifiers used with fixed-width integer");
+      Type = Context.getIntTypeForBitwidth(BitWidth, !Unsigned);
+    } else {
       if (HowLong == 3)
         Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
       else if (HowLong == 2)
         Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
       else if (HowLong == 1)
         Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
       else
         Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
+    }
     break;
+  }
   case 'c':
     assert(HowLong == 0 && "Bad modifiers used with 'c'!");
     if (Signed)
       Type = Context.SignedCharTy;
     else if (Unsigned)
       Type = Context.UnsignedCharTy;
     else
       Type = Context.CharTy;

test/CodeGen/builtins.c

#define V(n,args) p(#n #args, (__builtin_##n args, 0))
   V(__strcpy_chk, (s0, s1, n));
   s0[0] = 0;
   V(__strcat_chk, (s0, s1, n));
   P(object_size, (s0, 0));
   P(object_size, (s0, 1));
   P(object_size, (s0, 2));
   P(object_size, (s0, 3));
 
-  // Whatever
-
+  // CHECK: @llvm.bswap.i16
+  // CHECK: @llvm.bswap.i32
+  // CHECK: @llvm.bswap.i64
   P(bswap16, (N));
   P(bswap32, (N));
   P(bswap64, (N));
 
   // CHECK: @llvm.bitreverse.i8
   // CHECK: @llvm.bitreverse.i16
   // CHECK: @llvm.bitreverse.i32
   // CHECK: @llvm.bitreverse.i64
void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) {
   // CHECK: store i8 8, i8* [[ARG2_SIZE]]
   // CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 14
   // CHECK: [[ARG2_PTR:%.*]] = bitcast i8* [[ARG2]] to i8**
   // CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA2_ADDR]]
   // CHECK: store i8* [[DATA2]], i8** [[ARG2_PTR]]
   __builtin_os_log_format(buf, "%s %% %s", data1, data2);
 }
 
-#endif
+#endif