[WIP][clang] Allow {u}int_fastN_t to be different to {u}int_leastN_t

[lenary]

Summary

This is in order to support psABIs where these two type sizes do not match for
specific values of N. The default implementation matches clang's current
behaviour where getLeastIntTypeByWidth is used for {u}int_fastN_t.

This patch is a Work-In-Progress. I am seeking guidance as to how to update
clang's stdint.h to match this change.

clang/include/clang/Basic/TargetInfo.h

public:
   ///
   /// For example, SignedInt -> getIntWidth().
   unsigned getTypeWidth(IntType T) const;
 
   /// Return integer type with specified width.
   virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const;
 
   /// Return the smallest integer type with at least the specified width.
+  ///
+  /// This will be used for `{u}int_least<BitWidth>_t` in C.
   virtual IntType getLeastIntTypeByWidth(unsigned BitWidth,
                                          bool IsSigned) const;
 
+  /// Return the "fastest" integer type with at least the specified width.
+  ///
+  /// This will be used for `{u}int_fast<BitWidth>_t` in C.
+  ///
+  /// The default implementation will match getLeastIntTypeByWidth.
+  virtual IntType getFastIntTypeByWidth(unsigned BitWidth,
+                                        bool IsSigned) const {
+    return getLeastIntTypeByWidth(BitWidth, IsSigned);
+  }
+
   /// Return floating point type with specified width. On PPC, there are
   /// three possible types for 128-bit floating point: "PPC double-double",
   /// IEEE 754R quad precision, and "long double" (which under the covers
   /// is represented as one of those two). At this time, there is no support
   /// for an explicit "PPC double-double" type (i.e. __ibm128) so we only
   /// need to differentiate between "long double" and IEEE quad precision.
   RealType getRealTypeByWidth(unsigned BitWidth, bool ExplicitIEEE) const;
 

clang/lib/Frontend/InitPreprocessor.cpp

static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned,
   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
 }
 
 static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
                               const TargetInfo &TI, MacroBuilder &Builder) {
   // stdint.h currently defines the fast int types as equivalent to the least
   // types.
-  TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
+  TargetInfo::IntType Ty = TI.getFastIntTypeByWidth(TypeWidth, IsSigned);
   if (Ty == TargetInfo::NoInt)
     return;
 
   const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
   DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
 
   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);