Allow __ieee128 as an alias to __float128 on ppc

[serge-sans-paille]

Summary

This matches gcc behavior

[qiucf]

Hi, you mentioned that this patch aliases __ieee128 to __float128 on PPC. But this seems a target-independent change, right?

The change itself looks reasonable since libstdcxx may refer to __ieee128 type.

[nemanjai]

In D97846#2602012, @qiucf wrote:

Hi, you mentioned that this patch aliases __ieee128 to __float128 on PPC. But this seems a target-independent change, right?

The change itself looks reasonable since libstdcxx may refer to __ieee128 type.

I agree that this looks fine as long as the title is fixed up - it is not target specific and it is also not __ieee18 but __ieee128. Since it is target independent, you may want @rsmith to have a look as well.

[jwakely]

GCC only defines __ieee128 for 64-bit power, and libstdc++ only uses it for 64-bit power if the C library supports it.

[serge-sans-paille]

Update description, and update implementation to more closely match gcc behavior.

[serge-sans-paille]

This should be ppc specific now.

[serge-sans-paille]

@qiucf does it look good now?

[qiucf]

In D97846#2619479, @serge-sans-paille wrote:

@qiucf does it look good now?

Thanks. This looks fine to me. See if there're any comments from other reviewers.

[hubert.reinterpretcast]

GCC doesn't seem to implement this as a keyword?

namespace Q { int __ieee128; } // compiles

[serge-sans-paille]

In D97846#2623792, @hubert.reinterpretcast wrote:

GCC doesn't seem to implement this as a keyword?

namespace Q { int __ieee128; } // compiles

Correct. That being said, using an identifier starting with __ is UB in C and C++, so I guess it's not critical (?). I'm open to suggestion on how to implement that behavior in clang though :-)

[jwakely]

In D97846#2623792, @hubert.reinterpretcast wrote:

GCC doesn't seem to implement this as a keyword?

namespace Q { int __ieee128; } // compiles

That seems to be true for __float128 too, even on x86_64. I'll find out what's going on there.

Edit: and also __float80 on x86. Maybe a bug (or "feature") of target-specific built-in types in GCC. I'll find out on Monday.

As Serge said, it's UB to use that as an identifier, so not a show stopper, and Clang and GCC already diverge here for existing types.

[jwakely]

In D97846#2624059, @serge-sans-paille wrote:

I'm open to suggestion on how to implement that behavior in clang though :-)

My suggestion would be "don't", because GCC's behaviour doesn't make sense!

[serge-sans-paille]

My suggestion would be "don't", because GCC's behaviour doesn't make sense!

@qiucf based on @jwakely feedback, I'm going to leave the implementation as is :-)

[hubert.reinterpretcast]

LGTM; thanks.

[serge-sans-paille]

Thanks @hubert.reinterpretcast , @jwakely and @qiucf for the feedback on that review!

clang/include/clang/Basic/LangOptions.def

BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,
                "Objective-C related result type inference")
 LANGOPT(AppExt , 1, 0, "Objective-C App Extension")
 LANGOPT(Trigraphs         , 1, 0,"trigraphs")
 LANGOPT(LineComment       , 1, 0, "'//' comments")
 LANGOPT(Bool              , 1, 0, "bool, true, and false keywords")
 LANGOPT(Half              , 1, 0, "half keyword")
 LANGOPT(WChar             , 1, CPlusPlus, "wchar_t keyword")
 LANGOPT(Char8             , 1, 0, "char8_t keyword")
+LANGOPT(IEEE128           , 1, 0, "__ieee128 keyword")
 LANGOPT(DeclSpecKeyword   , 1, 0, "__declspec keyword")
 BENIGN_LANGOPT(DollarIdents   , 1, 1, "'$' in identifiers")
 BENIGN_LANGOPT(AsmPreprocessor, 1, 0, "preprocessor in asm mode")
 LANGOPT(GNUMode           , 1, 1, "GNU extensions")
 LANGOPT(GNUKeywords       , 1, 1, "GNU keywords")
 VALUE_LANGOPT(GNUCVersion , 32, 0, "GNU C compatibility version")
 BENIGN_LANGOPT(ImplicitInt, 1, !C99 && !CPlusPlus, "C89 implicit 'int'")
 LANGOPT(Digraphs          , 1, 0, "digraphs")

clang/lib/Basic/IdentifierTable.cpp

#include "clang/Basic/TokenKinds.def"
 
   if (LangOpts.ParseUnknownAnytype)
     AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL,
                LangOpts, *this);
 
   if (LangOpts.DeclSpecKeyword)
     AddKeyword("__declspec", tok::kw___declspec, KEYALL, LangOpts, *this);
 
+  if (LangOpts.IEEE128)
+    AddKeyword("__ieee128", tok::kw___float128, KEYALL, LangOpts, *this);
+
   // Add the 'import' contextual keyword.
   get("import").setModulesImport(true);
 }
 
 /// Checks if the specified token kind represents a keyword in the
 /// specified language.
 /// \returns Status of the keyword in the language.
 static KeywordStatus getTokenKwStatus(const LangOptions &LangOpts,

clang/lib/Basic/Targets/PPC.cpp

 void PPCTargetInfo::adjust(LangOptions &Opts) {
   if (HasAltivec)
     Opts.AltiVec = 1;
   TargetInfo::adjust(Opts);
   if (LongDoubleFormat != &llvm::APFloat::IEEEdouble())
     LongDoubleFormat = Opts.PPCIEEELongDouble
                            ? &llvm::APFloat::IEEEquad()
                            : &llvm::APFloat::PPCDoubleDouble();
+  Opts.IEEE128 = 1;
 }
 
 ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const {
   return llvm::makeArrayRef(BuiltinInfo, clang::PPC::LastTSBuiltin -
                                              Builtin::FirstTSBuiltin);
 }

clang/test/Sema/128bitfloat.cpp

 // RUN: %clang_cc1 -verify -std=gnu++11 %s
 // RUN: %clang_cc1 -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple powerpc64-linux -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple i686-windows-gnu -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple x86_64-windows-gnu -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -verify -std=c++11 %s
 
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+
+#if defined(__ppc__)
+template <typename> struct __is_float128 { static constexpr bool value = false; };
+template <> struct __is_float128<__float128> { static constexpr bool value = true; };
+static_assert(__is_float128<__ieee128>::value, "__ieee128 aliases to __float128");
+#endif
+
 __float128 f;
 template<typename> struct __is_floating_point_helper {};
 template<> struct __is_floating_point_helper<__float128> {};
 int g(int x, __float128 *y) {
   return x + *y;
 }
 
 // expected-no-diagnostics