WIP: Ensure that the type of size_t is represended as one of the fixed width types

[sbc100]

Summary

We recently changes size_t on wasm from int to long which
had the effect of making the type of size_t (long) not match either
int32_t or int64_t.

This solution is not very elegant but fixes the build issues that
resulted from this change.

[sbc100]

remove debugging

[joerg]

I don't understand the desire for this logic. Why can't wasm override the rest of the types if it wants to have something special?

[sbc100]

Please ignore this change, I had thought we wanted size_t to match either int32_t or int64_t, but it turns out that isn't a requirement and that code that expects this to be true needs fixing.

lib/Frontend/InitPreprocessor.cpp

static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty,
   for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) {
     Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__",
                         Twine("\"") + FmtModifier + Twine(*Fmt) + "\"");
   }
 }
 
 static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
                        MacroBuilder &Builder) {
+  printf("macro = %s\n", MacroName.str().c_str());
+  printf("name = %s\n", TargetInfo::getTypeName(Ty));
   Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
 }
 
 static void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty,
                             const TargetInfo &TI, MacroBuilder &Builder) {
   Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
 }
 
 static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
                              const TargetInfo &TI, MacroBuilder &Builder) {
   Builder.defineMacro(MacroName,
                       Twine(BitWidth / TI.getCharWidth()));
 }
 
 static void DefineExactWidthIntType(TargetInfo::IntType Ty,
                                     const TargetInfo &TI,
                                     MacroBuilder &Builder) {
   int TypeWidth = TI.getTypeWidth(Ty);
   bool IsSigned = TI.isTypeSigned(Ty);
+  printf("DefineExactWidthIntType\n");
 
   // Use the target specified int64 type, when appropriate, so that [u]int64_t
   // ends up being defined in terms of the correct type.
   if (TypeWidth == 64)
     Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
 
   const char *Prefix = IsSigned ? "__INT" : "__UINT";
 
if (!LangOpts.CharIsSigned)
     Builder.defineMacro("__CHAR_UNSIGNED__");
 
   if (!TargetInfo::isTypeSigned(TI.getWCharType()))
     Builder.defineMacro("__WCHAR_UNSIGNED__");
 
   if (!TargetInfo::isTypeSigned(TI.getWIntType()))
     Builder.defineMacro("__WINT_UNSIGNED__");
 
+  unsigned SizeTypeWidth = TI.getTypeWidth(TI.getSizeType());
+
   // Define exact-width integer types for stdint.h
   DefineExactWidthIntType(TargetInfo::SignedChar, TI, Builder);
 
   if (TI.getShortWidth() > TI.getCharWidth())
     DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder);
 
-  if (TI.getIntWidth() > TI.getShortWidth())
+  if (TI.getIntWidth() > TI.getShortWidth() && !(TI.getIntWidth() == SizeTypeWidth && TI.getSignedSizeType() != TargetInfo::SignedInt))
     DefineExactWidthIntType(TargetInfo::SignedInt, TI, Builder);
 
-  if (TI.getLongWidth() > TI.getIntWidth())
+  if (TI.getLongWidth() > TI.getIntWidth() || TI.getSignedSizeType() == TargetInfo::SignedLong)
     DefineExactWidthIntType(TargetInfo::SignedLong, TI, Builder);
 
   if (TI.getLongLongWidth() > TI.getLongWidth())
     DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder);
 
   DefineExactWidthIntType(TargetInfo::UnsignedChar, TI, Builder);
   DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder);
   DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder);
 
   if (TI.getShortWidth() > TI.getCharWidth()) {
     DefineExactWidthIntType(TargetInfo::UnsignedShort, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder);
   }
 
-  if (TI.getIntWidth() > TI.getShortWidth()) {
+  if (TI.getIntWidth() > TI.getShortWidth() && !(TI.getIntWidth() == SizeTypeWidth && TI.getSizeType() != TargetInfo::UnsignedInt)) {
     DefineExactWidthIntType(TargetInfo::UnsignedInt, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder);
   }
 
-  if (TI.getLongWidth() > TI.getIntWidth()) {
+  if (TI.getLongWidth() > TI.getIntWidth() || TI.getSizeType() == TargetInfo::UnsignedLong) {
     DefineExactWidthIntType(TargetInfo::UnsignedLong, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder);
   }
 
   if (TI.getLongLongWidth() > TI.getLongWidth()) {
     DefineExactWidthIntType(TargetInfo::UnsignedLongLong, TI, Builder);
     DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder);