CodeGen: Reduce LValue and CallArgList memory footprint before recommitting r326946

[yaxunl]

Summary

Recent change r326946 (https://reviews.llvm.org/D34367) causes regression in Eigen due to increased
memory footprint of CallArg.

This patch reduces LValue size from 112 to 96 bytes and reduces inline argument count of CallArgList
from 16 to 8.

It has been verified that this will let the added deep AST tree test pass with r326946.

In the long run, CallArg or LValue memory footprint should be further optimized.

[rjmccall]

lib/CodeGen/CGValue.h

234

Please saturate Alignment here instead of allowing it to be truncated: that is, if the passed-in alignment is greater than (1U << 31), please store (1U << 31).

[yaxunl]

Saturate alignment when it is too large.

[rjmccall]

Thank you. LGTM.

[yaxunl]

I have to remove the lit test since it causes failure on atom http://lab.llvm.org:8011/builders/clang-atom-d525-fedora-rel/builds/15477

It seems when the lit test is running on atom, it is compiled with default CPU for x86_64, therefor atom is not defined and there is no way to detect the test is running on atom system.

[rjmccall]

Yeah, I think the test is probably a bit abusive to run unconditionally for all hosts. We can just know that we improved things, and if we regress, it will break them again.

lib/CodeGen/CGCall.h

struct CallArg {
     CallArg(RValue rv, QualType ty, bool needscopy)
     : RV(rv), Ty(ty), NeedsCopy(needscopy)
     { }
   };
 
   /// CallArgList - Type for representing both the value and type of
   /// arguments in a call.
   class CallArgList :
-    public SmallVector<CallArg, 16> {
+    public SmallVector<CallArg, 8> {
   public:
     CallArgList() : StackBase(nullptr) {}
 
     struct Writeback {
       /// The original argument.  Note that the argument l-value
       /// is potentially null.
       LValue Source;
 

lib/CodeGen/CGValue.h

class LValue {
 
   QualType Type;
 
   // 'const' is unused here
   Qualifiers Quals;
 
   // The alignment to use when accessing this lvalue.  (For vector elements,
   // this is the alignment of the whole vector.)
-  int64_t Alignment;
+  unsigned Alignment;
 
   // objective-c's ivar
   bool Ivar:1;
   
   // objective-c's ivar is an array
   bool ObjIsArray:1;
 
   // LValue is non-gc'able for any reason, including being a parameter or local
   // variable.
   bool NonGC: 1;
 
   // Lvalue is a global reference of an objective-c object
   bool GlobalObjCRef : 1;
   
   // Lvalue is a thread local reference
   bool ThreadLocalRef : 1;
 
   // Lvalue has ARC imprecise lifetime.  We store this inverted to try
   // to make the default bitfield pattern all-zeroes.
   bool ImpreciseLifetime : 1;
 
-  LValueBaseInfo BaseInfo;
-  TBAAAccessInfo TBAAInfo;
-
   // This flag shows if a nontemporal load/stores should be used when accessing
   // this lvalue.
   bool Nontemporal : 1;
 
+  LValueBaseInfo BaseInfo;
+  TBAAAccessInfo TBAAInfo;
+
   Expr *BaseIvarExp;
 
 private:
   void Initialize(QualType Type, Qualifiers Quals, CharUnits Alignment,
                   LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo) {
     assert((!Alignment.isZero() || Type->isIncompleteType()) &&
            "initializing l-value with zero alignment!");
     this->Type = Type;
     this->Quals = Quals;
-    this->Alignment = Alignment.getQuantity();
+    const unsigned MaxAlign = 1U << 31;
+    this->Alignment = Alignment.getQuantity() <= MaxAlign
+                          ? Alignment.getQuantity()
+                          : MaxAlign;
     assert(this->Alignment == Alignment.getQuantity() &&
            "Alignment exceeds allowed max!");
     this->BaseInfo = BaseInfo;
     this->TBAAInfo = TBAAInfo;
 
     // Initialize Objective-C flags.
     this->Ivar = this->ObjIsArray = this->NonGC = this->GlobalObjCRef = false;
     this->ImpreciseLifetime = false;