[ARM NEON] Avoid duplicated decarations

[dnsampaio]

Summary

The declaration of arm neon intrinsics that are
"big endian safe" print the same code for big
and small endian targets.
This patch avoids duplicates by checking if an
intrinsic is safe to have a single definition.
(decreases header 11k lines out of 73k).

[dnsampaio]

• Consider BigEndianSafe intrinsics that all inputs and outputs are scalar or single element vectors

[dnsampaio]

Breaks the header. Needs to avoid generating calls to functions with predicated __noswap when it is BigEndianSafe.

[dnsampaio]

Fix / Update / Rebase

• Avoid appending __noswap_ to intrinsics that are BigEndianSafe
• Moved to monorepo

[ostannard]

LGTM with one small nit.

clang/utils/TableGen/NeonEmitter.cpp

1906 ↗

(On Diff #217594)

s/small endians/little endian/

[dnsampaio]

• Fix comment

cfe/trunk/utils/TableGen/NeonEmitter.cpp

class Intrinsic {
   /// The return variable.
   Variable RetVar;
   /// A postfix to apply to every variable. Defaults to "".
   std::string VariablePostfix;
 
   NeonEmitter &Emitter;
   std::stringstream OS;
 
+  bool isBigEndianSafe() const {
+    if (BigEndianSafe)
+      return true;
+
+    for (const auto &T : Types){
+      if (T.isVector() && T.getNumElements() > 1)
+        return false;
+    }
+    return true;
+  }
+
 public:
   Intrinsic(Record *R, StringRef Name, StringRef Proto, TypeSpec OutTS,
             TypeSpec InTS, ClassKind CK, ListInit *Body, NeonEmitter &Emitter,
             StringRef Guard, bool IsUnavailable, bool BigEndianSafe)
       : R(R), Name(Name.str()), Proto(Proto.str()), OutTS(OutTS), InTS(InTS),
         CK(CK), Body(Body), Guard(Guard.str()), IsUnavailable(IsUnavailable),
         BigEndianSafe(BigEndianSafe), NeededEarly(false), UseMacro(false),
         BaseType(OutTS, 'd'), InBaseType(InTS, 'd'), Emitter(Emitter) {
if (Dest.getType().getNumVectors() > 1) {
     for (int J = Dest.getType().getNumElements() - 1; J >= 0; --J)
       OS << ", " << J;
     OS << ");";
     emitNewLine();
   }
 }
 
 void Intrinsic::emitArgumentReversal() {
-  if (BigEndianSafe)
+  if (isBigEndianSafe())
     return;
 
   // Reverse all vector arguments.
   for (unsigned I = 0; I < getNumParams(); ++I) {
     std::string Name = "p" + utostr(I);
     std::string NewName = "rev" + utostr(I);
 
     Variable &V = Variables[Name];
     Variable NewV(V.getType(), NewName + VariablePostfix);
 
     if (!NewV.getType().isVector() || NewV.getType().getNumElements() == 1)
       continue;
 
     OS << "  " << NewV.getType().str() << " " << NewV.getName() << ";";
     emitReverseVariable(NewV, V);
     V = NewV;
   }
 }
 
 void Intrinsic::emitReturnReversal() {
-  if (BigEndianSafe)
+  if (isBigEndianSafe())
     return;
   if (!getReturnType().isVector() || getReturnType().isVoid() ||
       getReturnType().getNumElements() == 1)
     return;
   emitReverseVariable(RetVar, RetVar);
 }
 
 void Intrinsic::emitShadowedArgs() {
else
     N = emitDagArg(DI->getArg(0), "").second;
   Intrinsic &Callee = Intr.Emitter.getIntrinsic(N, Types);
 
   // Make sure the callee is known as an early def.
   Callee.setNeededEarly();
   Intr.Dependencies.insert(&Callee);
 
   // Now create the call itself.
-  std::string S = CallPrefix.str() + Callee.getMangledName(true) + "(";
+  std::string S = "";
+  if (!Callee.isBigEndianSafe())
+    S += CallPrefix.str();
+  S += Callee.getMangledName(true) + "(";
   for (unsigned I = 0; I < DI->getNumArgs() - 1; ++I) {
     if (I != 0)
       S += ", ";
     S += Values[I];
   }
   S += ")";
 
   return std::make_pair(Callee.getReturnType(), S);
Intrinsic::DagEmitter::emitDagArg(Init *Arg, std::string ArgName) {
   assert(Arg && "Neither ArgName nor Arg?!");
   DagInit *DI = dyn_cast<DagInit>(Arg);
   assert_with_loc(DI, "Arguments must either be DAGs or names!");
 
   return emitDag(DI);
 }
 
 std::string Intrinsic::generate() {
+  // Avoid duplicated code for big and little endian
+  if (isBigEndianSafe()) {
+    generateImpl(false, "", "");
+    return OS.str();
+  }
   // Little endian intrinsics are simple and don't require any argument
   // swapping.
   OS << "#ifdef __LITTLE_ENDIAN__\n";
 
   generateImpl(false, "", "");
 
   OS << "#else\n";