[clang] 229c95a - [CodeCompletion] Signature help for aggregate initialization.

[Sam McCall via cfe-commits]

Author: Sam McCall
Date: 2022-01-04T16:00:22+01:00
New Revision: 229c95ab661d89d29a64bff014229b7c6d3ee8a1

URL: https://github.com/llvm/llvm-project/commit/229c95ab661d89d29a64bff014229b7c6d3ee8a1
DIFF: https://github.com/llvm/llvm-project/commit/229c95ab661d89d29a64bff014229b7c6d3ee8a1.diff

LOG: [CodeCompletion] Signature help for aggregate initialization.

The "parameter list" is the list of fields which should be initialized.
We introduce a new OverloadCandidate kind for this.
It starts to become harder for CC consumers to handle all the cases for
params, so I added some extra APIs on OverloadCandidate to abstract them.

Includes some basic support for designated initializers.
The same aggregate signature is shown, the current arg jumps after the
one you just initialized. This follows C99 semantics for mixed
designated/positional initializers (which clang supports in C++ as an extension)
and is also a useful prompt for C++ as C++ designated initializers must be
in order.

Related bugs:
 - https://github.com/clangd/clangd/issues/965
 - https://github.com/clangd/clangd/issues/306

Differential Revision: https://reviews.llvm.org/D116326

Added: 
    tl

Modified: 
    clang-tools-extra/clangd/CodeComplete.cpp
    clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
    clang/include/clang/Sema/CodeCompleteConsumer.h
    clang/lib/Sema/CodeCompleteConsumer.cpp
    clang/lib/Sema/SemaCodeComplete.cpp
    clang/test/CodeCompletion/ctor-signature.cpp

Removed: 
    


################################################################################
diff  --git a/clang-tools-extra/clangd/CodeComplete.cpp b/clang-tools-extra/clangd/CodeComplete.cpp
index 53d8f0d6cdeb7..50388e08c30aa 100644
--- a/clang-tools-extra/clangd/CodeComplete.cpp
+++ b/clang-tools-extra/clangd/CodeComplete.cpp
@@ -896,10 +896,7 @@ struct ScoredSignature {
 int paramIndexForArg(const CodeCompleteConsumer::OverloadCandidate &Candidate,
                      int Arg) {
   int NumParams = Candidate.getNumParams();
-  if (const auto *F = Candidate.getFunction()) {
-    if (F->isVariadic())
-      ++NumParams;
-  } else if (auto *T = Candidate.getFunctionType()) {
+  if (auto *T = Candidate.getFunctionType()) {
     if (auto *Proto = T->getAs<FunctionProtoType>()) {
       if (Proto->isVariadic())
         ++NumParams;
@@ -996,8 +993,7 @@ class SignatureHelpCollector final : public CodeCompleteConsumer {
                                     const ScoredSignature &R) {
       // Ordering follows:
       // - Less number of parameters is better.
-      // - Function is better than FunctionType which is better than
-      // Function Template.
+      // - Aggregate > Function > FunctionType > FunctionTemplate
       // - High score is better.
       // - Shorter signature is better.
       // - Alphabetically smaller is better.
@@ -1009,18 +1005,22 @@ class SignatureHelpCollector final : public CodeCompleteConsumer {
                R.Quality.NumberOfOptionalParameters;
       if (L.Quality.Kind != R.Quality.Kind) {
         using OC = CodeCompleteConsumer::OverloadCandidate;
-        switch (L.Quality.Kind) {
-        case OC::CK_Function:
-          return true;
-        case OC::CK_FunctionType:
-          return R.Quality.Kind != OC::CK_Function;
-        case OC::CK_FunctionTemplate:
-          return false;
-        case OC::CK_Template:
-          assert(false && "Never see templates and other overloads mixed");
-          return false;
-        }
-        llvm_unreachable("Unknown overload candidate type.");
+        auto KindPriority = [&](OC::CandidateKind K) {
+          switch (K) {
+          case OC::CK_Aggregate:
+            return 1;
+          case OC::CK_Function:
+            return 2;
+          case OC::CK_FunctionType:
+            return 3;
+          case OC::CK_FunctionTemplate:
+            return 4;
+          case OC::CK_Template:
+            return 5;
+          }
+          llvm_unreachable("Unknown overload candidate type.");
+        };
+        return KindPriority(L.Quality.Kind) < KindPriority(R.Quality.Kind);
       }
       if (L.Signature.label.size() != R.Signature.label.size())
         return L.Signature.label.size() < R.Signature.label.size();
@@ -1171,24 +1171,9 @@ class ParamNameCollector final : public CodeCompleteConsumer {
            "too many arguments");
 
     for (unsigned I = 0; I < NumCandidates; ++I) {
-      OverloadCandidate Candidate = Candidates[I];
-      NamedDecl *Param = nullptr;
-      if (auto *Func = Candidate.getFunction()) {
-        if (CurrentArg < Func->getNumParams())
-          Param = Func->getParamDecl(CurrentArg);
-      } else if (auto *Template = Candidate.getTemplate()) {
-        if (CurrentArg < Template->getTemplateParameters()->size())
-          Param = Template->getTemplateParameters()->getParam(CurrentArg);
-      }
-
-      if (!Param)
-        continue;
-      auto *Ident = Param->getIdentifier();
-      if (!Ident)
-        continue;
-      auto Name = Ident->getName();
-      if (!Name.empty())
-        ParamNames.insert(Name.str());
+      if (const NamedDecl *ND = Candidates[I].getParamDecl(CurrentArg))
+        if (const auto *II = ND->getIdentifier())
+          ParamNames.emplace(II->getName());
     }
   }
 

diff  --git a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
index 9d5c57670be1f..52dee0fdc0e21 100644
--- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
@@ -1294,6 +1294,25 @@ TEST(SignatureHelpTest, Constructors) {
   CheckBracedInit("int x(S); int i = x({^});");
 }
 
+TEST(SignatureHelpTest, Aggregates) {
+  std::string Top = R"cpp(
+    struct S {
+      int a, b, c, d;
+    };
+  )cpp";
+  auto AggregateSig = Sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
+  EXPECT_THAT(signatures(Top + "S s{^}").signatures,
+              UnorderedElementsAre(AggregateSig, Sig("S{}"),
+                                   Sig("S{[[const S &]]}"),
+                                   Sig("S{[[S &&]]}")));
+  EXPECT_THAT(signatures(Top + "S s{1,^}").signatures,
+              ElementsAre(AggregateSig));
+  EXPECT_EQ(signatures(Top + "S s{1,^}").activeParameter, 1);
+  EXPECT_THAT(signatures(Top + "S s{.c=3,^}").signatures,
+              ElementsAre(AggregateSig));
+  EXPECT_EQ(signatures(Top + "S s{.c=3,^}").activeParameter, 3);
+}
+
 TEST(SignatureHelpTest, OverloadInitListRegression) {
   auto Results = signatures(R"cpp(
     struct A {int x;};

diff  --git a/clang/include/clang/Sema/CodeCompleteConsumer.h b/clang/include/clang/Sema/CodeCompleteConsumer.h
index 70c34703f0a00..41c495882b27b 100644
--- a/clang/include/clang/Sema/CodeCompleteConsumer.h
+++ b/clang/include/clang/Sema/CodeCompleteConsumer.h
@@ -1018,6 +1018,9 @@ class CodeCompleteConsumer {
 
       /// The candidate is a template, template arguments are being completed.
       CK_Template,
+
+      /// The candidate is aggregate initialization of a record type.
+      CK_Aggregate,
     };
 
   private:
@@ -1040,17 +1043,32 @@ class CodeCompleteConsumer {
       /// The template overload candidate, available when
       /// Kind == CK_Template.
       const TemplateDecl *Template;
+
+      /// The class being aggregate-initialized,
+      /// when Kind == CK_Aggregate
+      const RecordDecl *AggregateType;
     };
 
   public:
     OverloadCandidate(FunctionDecl *Function)
-        : Kind(CK_Function), Function(Function) {}
+        : Kind(CK_Function), Function(Function) {
+      assert(Function != nullptr);
+    }
 
     OverloadCandidate(FunctionTemplateDecl *FunctionTemplateDecl)
-        : Kind(CK_FunctionTemplate), FunctionTemplate(FunctionTemplateDecl) {}
+        : Kind(CK_FunctionTemplate), FunctionTemplate(FunctionTemplateDecl) {
+      assert(FunctionTemplateDecl != nullptr);
+    }
 
     OverloadCandidate(const FunctionType *Type)
-        : Kind(CK_FunctionType), Type(Type) {}
+        : Kind(CK_FunctionType), Type(Type) {
+      assert(Type != nullptr);
+    }
+
+    OverloadCandidate(const RecordDecl *Aggregate)
+        : Kind(CK_Aggregate), AggregateType(Aggregate) {
+      assert(Aggregate != nullptr);
+    }
 
     OverloadCandidate(const TemplateDecl *Template)
         : Kind(CK_Template), Template(Template) {}
@@ -1077,8 +1095,23 @@ class CodeCompleteConsumer {
       return Template;
     }
 
+    /// Retrieve the aggregate type being initialized.
+    const RecordDecl *getAggregate() const {
+      assert(getKind() == CK_Aggregate);
+      return AggregateType;
+    }
+
+    /// Get the number of parameters in this signature.
     unsigned getNumParams() const;
 
+    /// Get the type of the Nth parameter.
+    /// Returns null if the type is unknown or N is out of range.
+    QualType getParamType(unsigned N) const;
+
+    /// Get the declaration of the Nth parameter.
+    /// Returns null if the decl is unknown or N is out of range.
+    const NamedDecl *getParamDecl(unsigned N) const;
+
     /// Create a new code-completion string that describes the function
     /// signature of this overload candidate.
     CodeCompletionString *

diff  --git a/clang/lib/Sema/CodeCompleteConsumer.cpp b/clang/lib/Sema/CodeCompleteConsumer.cpp
index bb088fd5fe97f..fefe20941f179 100644
--- a/clang/lib/Sema/CodeCompleteConsumer.cpp
+++ b/clang/lib/Sema/CodeCompleteConsumer.cpp
@@ -508,6 +508,7 @@ CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
     return Type;
 
   case CK_Template:
+  case CK_Aggregate:
     return nullptr;
   }
 
@@ -517,11 +518,80 @@ CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
 unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const {
   if (Kind == CK_Template)
     return Template->getTemplateParameters()->size();
-  if (const auto *FPT = dyn_cast_or_null<FunctionProtoType>(getFunctionType()))
-    return FPT->getNumParams();
+
+  if (Kind == CK_Aggregate) {
+    unsigned Count =
+        std::distance(AggregateType->field_begin(), AggregateType->field_end());
+    if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType))
+      Count += CRD->getNumBases();
+    return Count;
+  }
+
+  if (const auto *FT = getFunctionType())
+    if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
+      return FPT->getNumParams();
+
   return 0;
 }
 
+QualType
+CodeCompleteConsumer::OverloadCandidate::getParamType(unsigned N) const {
+  if (Kind == CK_Aggregate) {
+    if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
+      if (N < CRD->getNumBases())
+        return std::next(CRD->bases_begin(), N)->getType();
+      N -= CRD->getNumBases();
+    }
+    for (const auto *Field : AggregateType->fields())
+      if (N-- == 0)
+        return Field->getType();
+    return QualType();
+  }
+
+  if (Kind == CK_Template) {
+    TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
+    if (N < TPL->size())
+      if (const auto *D = dyn_cast<NonTypeTemplateParmDecl>(TPL->getParam(N)))
+        return D->getType();
+    return QualType();
+  }
+
+  if (const auto *FT = getFunctionType())
+    if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
+      if (N < FPT->getNumParams())
+        return FPT->getParamType(N);
+  return QualType();
+}
+
+const NamedDecl *
+CodeCompleteConsumer::OverloadCandidate::getParamDecl(unsigned N) const {
+  if (Kind == CK_Aggregate) {
+    if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
+      if (N < CRD->getNumBases())
+        return std::next(CRD->bases_begin(), N)->getType()->getAsTagDecl();
+      N -= CRD->getNumBases();
+    }
+    for (const auto *Field : AggregateType->fields())
+      if (N-- == 0)
+        return Field;
+    return nullptr;
+  }
+
+  if (Kind == CK_Template) {
+    TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
+    if (N < TPL->size())
+      return TPL->getParam(N);
+    return nullptr;
+  }
+
+  // Note that if we only have a FunctionProtoType, we don't have param decls.
+  if (const auto *FD = getFunction()) {
+    if (N < FD->param_size())
+      return FD->getParamDecl(N);
+  }
+  return nullptr;
+}
+
 //===----------------------------------------------------------------------===//
 // Code completion consumer implementation
 //===----------------------------------------------------------------------===//

diff  --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp
index e2bf5edc7b5e7..e089f85420bc6 100644
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -2817,14 +2817,18 @@ formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
                        Optional<ArrayRef<QualType>> ObjCSubsts = None);
 
 static std::string
-FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
-                        bool SuppressName = false, bool SuppressBlock = false,
+FormatFunctionParameter(const PrintingPolicy &Policy,
+                        const DeclaratorDecl *Param, bool SuppressName = false,
+                        bool SuppressBlock = false,
                         Optional<ArrayRef<QualType>> ObjCSubsts = None) {
   // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid.
   // It would be better to pass in the param Type, which is usually available.
   // But this case is rare, so just pretend we fell back to int as elsewhere.
   if (!Param)
     return "int";
+  Decl::ObjCDeclQualifier ObjCQual = Decl::OBJC_TQ_None;
+  if (const auto *PVD = dyn_cast<ParmVarDecl>(Param))
+    ObjCQual = PVD->getObjCDeclQualifier();
   bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
   if (Param->getType()->isDependentType() ||
       !Param->getType()->isBlockPointerType()) {
@@ -2840,8 +2844,7 @@ FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
       Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
                                     ObjCSubstitutionContext::Parameter);
     if (ObjCMethodParam) {
-      Result =
-          "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
+      Result = "(" + formatObjCParamQualifiers(ObjCQual, Type);
       Result += Type.getAsString(Policy) + ")";
       if (Param->getIdentifier() && !SuppressName)
         Result += Param->getIdentifier()->getName();
@@ -2878,8 +2881,7 @@ FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
 
     if (ObjCMethodParam) {
       Result = Type.getAsString(Policy);
-      std::string Quals =
-          formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
+      std::string Quals = formatObjCParamQualifiers(ObjCQual, Type);
       if (!Quals.empty())
         Result = "(" + Quals + " " + Result + ")";
       if (Result.back() != ')')
@@ -3689,6 +3691,31 @@ const RawComment *clang::getParameterComment(
   return nullptr;
 }
 
+static void AddOverloadAggregateChunks(const RecordDecl *RD,
+                                       const PrintingPolicy &Policy,
+                                       CodeCompletionBuilder &Result,
+                                       unsigned CurrentArg) {
+  unsigned ChunkIndex = 0;
+  auto AddChunk = [&](llvm::StringRef Placeholder) {
+    if (ChunkIndex > 0)
+      Result.AddChunk(CodeCompletionString::CK_Comma);
+    const char *Copy = Result.getAllocator().CopyString(Placeholder);
+    if (ChunkIndex == CurrentArg)
+      Result.AddCurrentParameterChunk(Copy);
+    else
+      Result.AddPlaceholderChunk(Copy);
+    ++ChunkIndex;
+  };
+  // Aggregate initialization has all bases followed by all fields.
+  // (Bases are not legal in C++11 but in that case we never get here).
+  if (auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
+    for (const auto &Base : CRD->bases())
+      AddChunk(Base.getType().getAsString(Policy));
+  }
+  for (const auto &Field : RD->fields())
+    AddChunk(FormatFunctionParameter(Policy, Field));
+}
+
 /// Add function overload parameter chunks to the given code completion
 /// string.
 static void AddOverloadParameterChunks(ASTContext &Context,
@@ -3698,6 +3725,11 @@ static void AddOverloadParameterChunks(ASTContext &Context,
                                        CodeCompletionBuilder &Result,
                                        unsigned CurrentArg, unsigned Start = 0,
                                        bool InOptional = false) {
+  if (!Function && !Prototype) {
+    Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
+    return;
+  }
+
   bool FirstParameter = true;
   unsigned NumParams =
       Function ? Function->getNumParams() : Prototype->getNumParams();
@@ -3851,22 +3883,13 @@ CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
 
   FunctionDecl *FDecl = getFunction();
   const FunctionProtoType *Proto =
-      dyn_cast<FunctionProtoType>(getFunctionType());
-  if (!FDecl && !Proto) {
-    // Function without a prototype. Just give the return type and a
-    // highlighted ellipsis.
-    const FunctionType *FT = getFunctionType();
-    Result.AddResultTypeChunk(Result.getAllocator().CopyString(
-        FT->getReturnType().getAsString(Policy)));
-    Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace
-                           : CodeCompletionString::CK_LeftParen);
-    Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
-    Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace
-                           : CodeCompletionString::CK_RightParen);
-    return Result.TakeString();
-  }
+      dyn_cast_or_null<FunctionProtoType>(getFunctionType());
 
-  if (FDecl) {
+  // First, the name/type of the callee.
+  if (getKind() == CK_Aggregate) {
+    Result.AddTextChunk(
+        Result.getAllocator().CopyString(getAggregate()->getName()));
+  } else if (FDecl) {
     if (IncludeBriefComments) {
       if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
         Result.addBriefComment(RC->getBriefText(S.getASTContext()));
@@ -3878,14 +3901,19 @@ CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
     FDecl->getDeclName().print(OS, Policy);
     Result.AddTextChunk(Result.getAllocator().CopyString(OS.str()));
   } else {
+    // Function without a declaration. Just give the return type.
     Result.AddResultTypeChunk(Result.getAllocator().CopyString(
-        Proto->getReturnType().getAsString(Policy)));
+        getFunctionType()->getReturnType().getAsString(Policy)));
   }
 
+  // Next, the brackets and parameters.
   Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace
                          : CodeCompletionString::CK_LeftParen);
-  AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
-                             CurrentArg);
+  if (getKind() == CK_Aggregate)
+    AddOverloadAggregateChunks(getAggregate(), Policy, Result, CurrentArg);
+  else
+    AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
+                               CurrentArg);
   Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace
                          : CodeCompletionString::CK_RightParen);
 
@@ -5926,18 +5954,18 @@ static QualType getParamType(Sema &SemaRef,
   // overload candidates.
   QualType ParamType;
   for (auto &Candidate : Candidates) {
-    // FIXME: handle non-type-template-parameters by merging with D116326
-    if (const auto *FType = Candidate.getFunctionType())
-      if (const auto *Proto = dyn_cast<FunctionProtoType>(FType))
-        if (N < Proto->getNumParams()) {
-          if (ParamType.isNull())
-            ParamType = Proto->getParamType(N);
-          else if (!SemaRef.Context.hasSameUnqualifiedType(
-                       ParamType.getNonReferenceType(),
-                       Proto->getParamType(N).getNonReferenceType()))
-            // Otherwise return a default-constructed QualType.
-            return QualType();
-        }
+    QualType CandidateParamType = Candidate.getParamType(N);
+    if (CandidateParamType.isNull())
+      continue;
+    if (ParamType.isNull()) {
+      ParamType = CandidateParamType;
+      continue;
+    }
+    if (!SemaRef.Context.hasSameUnqualifiedType(
+            ParamType.getNonReferenceType(),
+            CandidateParamType.getNonReferenceType()))
+      // Two conflicting types, give up.
+      return QualType();
   }
 
   return ParamType;
@@ -6058,6 +6086,73 @@ QualType Sema::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args,
   return !CandidateSet.empty() ? ParamType : QualType();
 }
 
+// Determine which param to continue aggregate initialization from after
+// a designated initializer.
+//
+// Given struct S { int a,b,c,d,e; }:
+//   after `S{.b=1,`       we want to suggest c to continue
+//   after `S{.b=1, 2,`    we continue with d (this is legal C and ext in C++)
+//   after `S{.b=1, .a=2,` we continue with b (this is legal C and ext in C++)
+//
+// Possible outcomes:
+//   - we saw a designator for a field, and continue from the returned index.
+//     Only aggregate initialization is allowed.
+//   - we saw a designator, but it was complex or we couldn't find the field.
+//     Only aggregate initialization is possible, but we can't assist with it.
+//     Returns an out-of-range index.
+//   - we saw no designators, just positional arguments.
+//     Returns None.
+static llvm::Optional<unsigned>
+getNextAggregateIndexAfterDesignatedInit(const ResultCandidate &Aggregate,
+                                         ArrayRef<Expr *> Args) {
+  static constexpr unsigned Invalid = std::numeric_limits<unsigned>::max();
+  assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate);
+
+  // Look for designated initializers.
+  // They're in their syntactic form, not yet resolved to fields.
+  IdentifierInfo *DesignatedFieldName = nullptr;
+  unsigned ArgsAfterDesignator = 0;
+  for (const Expr *Arg : Args) {
+    if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Arg)) {
+      if (DIE->size() == 1 && DIE->getDesignator(0)->isFieldDesignator()) {
+        DesignatedFieldName = DIE->getDesignator(0)->getFieldName();
+        ArgsAfterDesignator = 0;
+      } else {
+        return Invalid; // Complicated designator.
+      }
+    } else if (isa<DesignatedInitUpdateExpr>(Arg)) {
+      return Invalid; // Unsupported.
+    } else {
+      ++ArgsAfterDesignator;
+    }
+  }
+  if (!DesignatedFieldName)
+    return llvm::None;
+
+  // Find the index within the class's fields.
+  // (Probing getParamDecl() directly would be quadratic in number of fields).
+  unsigned DesignatedIndex = 0;
+  const FieldDecl *DesignatedField = nullptr;
+  for (const auto *Field : Aggregate.getAggregate()->fields()) {
+    if (Field->getIdentifier() == DesignatedFieldName) {
+      DesignatedField = Field;
+      break;
+    }
+    ++DesignatedIndex;
+  }
+  if (!DesignatedField)
+    return Invalid; // Designator referred to a missing field, give up.
+
+  // Find the index within the aggregate (which may have leading bases).
+  unsigned AggregateSize = Aggregate.getNumParams();
+  while (DesignatedIndex < AggregateSize &&
+         Aggregate.getParamDecl(DesignatedIndex) != DesignatedField)
+    ++DesignatedIndex;
+
+  // Continue from the index after the last named field.
+  return DesignatedIndex + ArgsAfterDesignator + 1;
+}
+
 QualType Sema::ProduceConstructorSignatureHelp(QualType Type,
                                                SourceLocation Loc,
                                                ArrayRef<Expr *> Args,
@@ -6065,48 +6160,72 @@ QualType Sema::ProduceConstructorSignatureHelp(QualType Type,
                                                bool Braced) {
   if (!CodeCompleter)
     return QualType();
+  SmallVector<ResultCandidate, 8> Results;
 
   // A complete type is needed to lookup for constructors.
-  CXXRecordDecl *RD =
-      isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
+  RecordDecl *RD =
+      isCompleteType(Loc, Type) ? Type->getAsRecordDecl() : nullptr;
   if (!RD)
     return Type;
-  // FIXME: we don't support signature help for aggregate initialization, so
-  //        don't offer a confusing partial list (e.g. the copy constructor).
-  if (Braced && RD->isAggregate())
-    return Type;
+  CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD);
+
+  // Consider aggregate initialization.
+  // We don't check that types so far are correct.
+  // We also don't handle C99/C++17 brace-elision, we assume init-list elements
+  // are 1:1 with fields.
+  // FIXME: it would be nice to support "unwrapping" aggregates that contain
+  // a single subaggregate, like std::array<T, N> -> T __elements[N].
+  if (Braced && !RD->isUnion() &&
+      (!LangOpts.CPlusPlus || (CRD && CRD->isAggregate()))) {
+    ResultCandidate AggregateSig(RD);
+    unsigned AggregateSize = AggregateSig.getNumParams();
+
+    if (auto NextIndex =
+            getNextAggregateIndexAfterDesignatedInit(AggregateSig, Args)) {
+      // A designator was used, only aggregate init is possible.
+      if (*NextIndex >= AggregateSize)
+        return Type;
+      Results.push_back(AggregateSig);
+      return ProduceSignatureHelp(*this, Results, *NextIndex, OpenParLoc,
+                                  Braced);
+    }
+
+    // Describe aggregate initialization, but also constructors below.
+    if (Args.size() < AggregateSize)
+      Results.push_back(AggregateSig);
+  }
 
   // FIXME: Provide support for member initializers.
   // FIXME: Provide support for variadic template constructors.
 
-  OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
-
-  for (NamedDecl *C : LookupConstructors(RD)) {
-    if (auto *FD = dyn_cast<FunctionDecl>(C)) {
-      // FIXME: we can't yet provide correct signature help for initializer
-      //        list constructors, so skip them entirely.
-      if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD))
-        continue;
-      AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
-                           CandidateSet,
-                           /*SuppressUserConversions=*/false,
-                           /*PartialOverloading=*/true,
-                           /*AllowExplicit*/ true);
-    } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
-      if (Braced && LangOpts.CPlusPlus &&
-          isInitListConstructor(FTD->getTemplatedDecl()))
-        continue;
+  if (CRD) {
+    OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
+    for (NamedDecl *C : LookupConstructors(CRD)) {
+      if (auto *FD = dyn_cast<FunctionDecl>(C)) {
+        // FIXME: we can't yet provide correct signature help for initializer
+        //        list constructors, so skip them entirely.
+        if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD))
+          continue;
+        AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
+                             CandidateSet,
+                             /*SuppressUserConversions=*/false,
+                             /*PartialOverloading=*/true,
+                             /*AllowExplicit*/ true);
+      } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
+        if (Braced && LangOpts.CPlusPlus &&
+            isInitListConstructor(FTD->getTemplatedDecl()))
+          continue;
 
-      AddTemplateOverloadCandidate(
-          FTD, DeclAccessPair::make(FTD, C->getAccess()),
-          /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
-          /*SuppressUserConversions=*/false,
-          /*PartialOverloading=*/true);
+        AddTemplateOverloadCandidate(
+            FTD, DeclAccessPair::make(FTD, C->getAccess()),
+            /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
+            /*SuppressUserConversions=*/false,
+            /*PartialOverloading=*/true);
+      }
     }
+    mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
   }
 
-  SmallVector<ResultCandidate, 8> Results;
-  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
   return ProduceSignatureHelp(*this, Results, Args.size(), OpenParLoc, Braced);
 }
 

diff  --git a/clang/test/CodeCompletion/ctor-signature.cpp b/clang/test/CodeCompletion/ctor-signature.cpp
index b02c8811bbcf0..8f0cfacfc1155 100644
--- a/clang/test/CodeCompletion/ctor-signature.cpp
+++ b/clang/test/CodeCompletion/ctor-signature.cpp
@@ -42,13 +42,29 @@ int b3 = consumeBar({});
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:41:22 %s | FileCheck -check-prefix=CHECK-BRACED %s
 
 struct Aggregate {
-  // FIXME: no support for aggregates yet.
-  // CHECK-AGGREGATE-NOT: OVERLOAD: Aggregate{<#const Aggregate &#>}
-  // CHECK-AGGREGATE-NOT: OVERLOAD: {{.*}}first
   int first;
   int second;
+  int third;
 };
 
-Aggregate a{};
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:52:13 %s | FileCheck -check-prefix=CHECK-AGGREGATE %s
+Aggregate a{1, 2, 3};
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:13 %s | FileCheck -check-prefix=CHECK-AGGREGATE-1 %s
+// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#int first#>, int second, int third}
+// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:16 %s | FileCheck -check-prefix=CHECK-AGGREGATE-2 %s
+// CHECK-AGGREGATE-2: OVERLOAD: Aggregate{int first, <#int second#>, int third}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:18 %s | FileCheck -check-prefix=CHECK-AGGREGATE-3 %s
+// CHECK-AGGREGATE-3: OVERLOAD: Aggregate{int first, int second, <#int third#>}
 
+Aggregate d{.second=1, .first=2, 3, 4, };
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:13 %s | FileCheck -check-prefix=CHECK-DESIG-1 %s
+// CHECK-DESIG-1: OVERLOAD: Aggregate{<#int first#>, int second, int third}
+// CHECK-DESIG-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:24 %s | FileCheck -check-prefix=CHECK-DESIG-2 %s
+// CHECK-DESIG-2: OVERLOAD: Aggregate{int first, int second, <#int third#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:34 %s | FileCheck -check-prefix=CHECK-DESIG-3 %s
+// CHECK-DESIG-3: OVERLOAD: Aggregate{int first, <#int second#>, int third}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:37 %s | FileCheck -check-prefix=CHECK-DESIG-4 %s
+// CHECK-DESIG-4: OVERLOAD: Aggregate{int first, int second, <#int third#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:38 %s | FileCheck -check-prefix=CHECK-DESIG-5 %s --allow-empty
+// CHECK-DESIG-5-NOT: OVERLOAD

diff  --git "a/tl\033" "b/tl\033"
new file mode 100644
index 0000000000000..1a124a4c5c135
--- /dev/null
+++ "b/tl\033"
@@ -0,0 +1,1381 @@
+2a92efd0a239 (HEAD -> main, origin/main) HEAD@{0}: rebase (finish): returning to refs/heads/main
+2a92efd0a239 (HEAD -> main, origin/main) HEAD@{1}: rebase (pick): [CodeComplete] drop unused Scope param. NFC
+1379eb577607 HEAD@{2}: rebase (start): checkout origin/main
+1e3d96c67ff9 HEAD@{3}: commit: [CodeComplete] drop unused Scope param. NFC
+6231ef262415 HEAD@{4}: rebase (finish): returning to refs/heads/main
+6231ef262415 HEAD@{5}: rebase (start): checkout origin/main
+f1f5a85af8be HEAD@{6}: checkout: moving from aggregates to main
+c8b1ec7561fe (aggregates) HEAD@{7}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+fee43399f0af HEAD@{8}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+daf114e5c347 HEAD@{9}: rebase (continue) (finish): returning to refs/heads/aggregates
+daf114e5c347 HEAD@{10}: rebase (continue): [CodeCompletion] Signature help for aggregate initialization.
+f2b3e25f860e (configcompiler) HEAD@{11}: rebase (start): checkout origin/main
+4f17932fb479 HEAD@{12}: checkout: moving from configcompiler to aggregates
+f2b3e25f860e (configcompiler) HEAD@{13}: rebase (finish): returning to refs/heads/configcompiler
+f2b3e25f860e (configcompiler) HEAD@{14}: rebase (pick): [clangd] Add CompileFlags.Compiler option to override argv0
+f4ef79306cee HEAD@{15}: rebase (start): checkout origin/main
+6443bd3db307 HEAD@{16}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+0fa6fc0238fe HEAD@{17}: reset: moving to HEAD
+0fa6fc0238fe HEAD@{18}: checkout: moving from main to configcompiler
+f1f5a85af8be HEAD@{19}: rebase (finish): returning to refs/heads/main
+f1f5a85af8be HEAD@{20}: rebase (start): checkout origin/main
+09f8315bba39 (arraytype) HEAD@{21}: checkout: moving from bracehelp to main
+a61f34ea2502 (bracehelp) HEAD@{22}: commit: [clangd] Fix windows build after 478863ef58c7f7314e06
+92417eaf3329 HEAD@{23}: rebase (finish): returning to refs/heads/bracehelp
+92417eaf3329 HEAD@{24}: rebase (pick): [CodeCompletion] Signature help for braced constructor calls
+a390c9905d4d HEAD@{25}: rebase (start): checkout origin/main
+8da663369977 HEAD@{26}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+9ee52e712414 HEAD@{27}: rebase (continue) (finish): returning to refs/heads/bracehelp
+9ee52e712414 HEAD@{28}: rebase (continue): [CodeCompletion] Signature help for braced constructor calls
+364eb371012b HEAD@{29}: rebase (start): checkout origin/main
+b245d1eaec2d HEAD@{30}: checkout: moving from iwyustdlib to bracehelp
+478863ef58c7 (iwyustdlib) HEAD@{31}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+ee8a314f09c0 HEAD@{32}: rebase (finish): returning to refs/heads/iwyustdlib
+ee8a314f09c0 HEAD@{33}: rebase (pick): [clangd] Basic IncludeCleaner support for c/c++ standard library
+b9ed95afc4b1 HEAD@{34}: rebase (start): checkout origin/main
+f038610fb5f3 HEAD@{35}: checkout: moving from insertion_point to iwyustdlib
+fe68088d44f7 (insertion_point) HEAD@{36}: rebase (finish): returning to refs/heads/insertion_point
+fe68088d44f7 (insertion_point) HEAD@{37}: rebase (pick): [clangd] Helper for determining member insertion point.
+9e6f88b31a7f (tidydiags) HEAD@{38}: rebase (start): checkout origin/main
+aacd98d5b867 HEAD@{39}: checkout: moving from tidydiags to insertion_point
+9e6f88b31a7f (tidydiags) HEAD@{40}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+e9211c3dd6ba HEAD@{41}: rebase (finish): returning to refs/heads/tidydiags
+e9211c3dd6ba HEAD@{42}: rebase (pick): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+7505aeefc4e6 HEAD@{43}: rebase (start): checkout origin/main
+53abaad295f4 HEAD@{44}: checkout: moving from aggregates to tidydiags
+4f17932fb479 HEAD@{45}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+9cf82ca7e4ee HEAD@{46}: checkout: moving from tmplargs to aggregates
+cd45e8c7bc16 (tmplargs) HEAD@{47}: rebase (finish): returning to refs/heads/tmplargs
+cd45e8c7bc16 (tmplargs) HEAD@{48}: rebase (pick): [CodeCompletion] Signature help for template argument lists
+3a33c0b1ce0d HEAD@{49}: rebase (start): checkout origin/main
+36da2251bd60 HEAD@{50}: commit (amend): [CodeCompletion] Signature help for template argument lists
+ef7f8bce7503 HEAD@{51}: checkout: moving from arcpatch-D116218 to tmplargs
+f2b2aae6843b (arcpatch-D116218) HEAD@{52}: commit (amend): [clangd] Fix selection on multi-dimensional array.
+50f8215cc9be HEAD@{53}: commit (amend): [clangd] Fix selection on multi-dimensional array. (alternate version)
+85244a21fd16 HEAD@{54}: commit (amend): [clangd] Fix selection on multi-dimensional array. (alternate version)
+169e8e0af680 HEAD@{55}: rebase (finish): returning to refs/heads/arcpatch-D116218
+169e8e0af680 HEAD@{56}: rebase (pick): [clangd] Fix selection on multi-dimensional array.
+ca271f4ef5a2 HEAD@{57}: rebase (start): checkout origin/main
+70d0857a4dea HEAD@{58}: commit: [clangd] Fix selection on multi-dimensional array.
+09f8315bba39 (arraytype) HEAD@{59}: checkout: moving from main to arcpatch-D116218
+09f8315bba39 (arraytype) HEAD@{60}: checkout: moving from tmplargs to main
+ef7f8bce7503 HEAD@{61}: commit (amend): [CodeCompletion] Signature help for template argument lists
+a7b31d694812 HEAD@{62}: checkout: moving from insertion_point to tmplargs
+aacd98d5b867 HEAD@{63}: commit (amend): [clangd] Helper for determining member insertion point.
+ac972fe4ff15 HEAD@{64}: checkout: moving from main to insertion_point
+09f8315bba39 (arraytype) HEAD@{65}: reset: moving to HEAD
+09f8315bba39 (arraytype) HEAD@{66}: checkout: moving from constructor to main
+41fbc109a1ae (constructor) HEAD@{67}: commit (amend): [clangd] Add code action to generate a constructor for a C++ class
+8e709f570606 HEAD@{68}: commit (amend): [clangd] Add code action to generate a constructor for a C++ class
+456dc7755f32 HEAD@{69}: commit: [clangd] Add code action to generate a constructor for a C++ class
+ac972fe4ff15 HEAD@{70}: checkout: moving from insertion_point to constructor
+ac972fe4ff15 HEAD@{71}: checkout: moving from constructor to insertion_point
+09f8315bba39 (arraytype) HEAD@{72}: reset: moving to HEAD
+09f8315bba39 (arraytype) HEAD@{73}: checkout: moving from constructor to constructor
+09f8315bba39 (arraytype) HEAD@{74}: reset: moving to HEAD~1
+aa6435e963ca HEAD@{75}: checkout: moving from insertion_point to constructor
+ac972fe4ff15 HEAD@{76}: checkout: moving from constructor to insertion_point
+aa6435e963ca HEAD@{77}: commit (amend): [clangd] Helper for determining member insertion point.
+45d6b0cd4780 HEAD@{78}: commit (amend): [clangd] Helper for determining member insertion point.
+ac972fe4ff15 HEAD@{79}: checkout: moving from insertion_point to constructor
+ac972fe4ff15 HEAD@{80}: checkout: moving from specialmember to insertion_point
+60a028a904d5 (specialmember) HEAD@{81}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+939996aed14e HEAD@{82}: checkout: moving from 939996aed14ec84df8cce3f4a5ec4988c4a1f564 to specialmember
+939996aed14e HEAD@{83}: rebase (pick): [clangd] Code action to declare missing move/copy constructor/assignment
+ac972fe4ff15 HEAD@{84}: rebase (start): checkout insertion_point
+bbeef89ae1af HEAD@{85}: checkout: moving from specialmember to bbeef89ae1af
+ac972fe4ff15 HEAD@{86}: rebase (finish): returning to refs/heads/specialmember
+ac972fe4ff15 HEAD@{87}: rebase (start): checkout insertion_point
+bbeef89ae1af HEAD@{88}: checkout: moving from insertion_point to specialmember
+ac972fe4ff15 HEAD@{89}: commit (amend): [clangd] Helper for determining member insertion point.
+0eac12f86ab3 HEAD@{90}: commit (amend): [clangd] Helper for determining member insertion point.
+156bab8c3ab7 HEAD@{91}: commit (amend): [clangd] Helper for determining member insertion point.
+da546cc68656 HEAD@{92}: commit (amend): [clangd] Helper for determining member insertion point.
+407f5558b48c HEAD@{93}: commit: [clangd] Helper for determining member insertion point.
+09f8315bba39 (arraytype) HEAD@{94}: checkout: moving from main to insertion_point
+09f8315bba39 (arraytype) HEAD@{95}: checkout: moving from specialmember to main
+bbeef89ae1af HEAD@{96}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+a66453e487e3 HEAD@{97}: reset: moving to HEAD
+a66453e487e3 HEAD@{98}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+31c647f871a8 HEAD@{99}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+500372f1ac6d HEAD@{100}: reset: moving to HEAD
+500372f1ac6d HEAD@{101}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+174dac9746f1 HEAD@{102}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+34bba952dadc HEAD@{103}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+8b2288785c88 HEAD@{104}: commit: [clangd] Code action to declare missing move/copy constructor/assignment
+09f8315bba39 (arraytype) HEAD@{105}: checkout: moving from main to specialmember
+09f8315bba39 (arraytype) HEAD@{106}: checkout: moving from typeDefinition to main
+6fbb2e3eca26 (typeDefinition) HEAD@{107}: commit (amend): [clangd] Implement textDocument/typeDefinition
+1ea84876711e HEAD@{108}: commit (amend): [clangd] Implement textDocument/typeDefinition
+2bf2e73c73d9 HEAD@{109}: commit (amend): [clangd] Implement textDocument/typeDefinition
+d15e5a597103 HEAD@{110}: commit (amend): [clangd] Implement textDocument/typeDefinition
+494458626828 HEAD@{111}: commit: [clangd] Implement textDocument/typeDefinition
+09f8315bba39 (arraytype) HEAD@{112}: checkout: moving from main to typeDefinition
+09f8315bba39 (arraytype) HEAD@{113}: rebase (finish): returning to refs/heads/main
+09f8315bba39 (arraytype) HEAD@{114}: rebase (start): checkout origin/main
+72ea6fbc150a HEAD@{115}: checkout: moving from arraytype to main
+09f8315bba39 (arraytype) HEAD@{116}: rebase (finish): returning to refs/heads/arraytype
+09f8315bba39 (arraytype) HEAD@{117}: rebase (pick): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+ed67d5a03aaf HEAD@{118}: rebase (start): checkout origin/main
+5c3e13fb9825 HEAD@{119}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+991036e41b3b HEAD@{120}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+47ffbac82a3f HEAD@{121}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+9923e86a3a96 HEAD@{122}: rebase (continue) (finish): returning to refs/heads/arraytype
+9923e86a3a96 HEAD@{123}: rebase (continue): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+15787ccd4574 HEAD@{124}: rebase (start): checkout origin/main
+1dc8f4774d34 HEAD@{125}: rebase (abort): updating HEAD
+0651768d7a19 HEAD@{126}: rebase (pick): updated suggesting/coloring of call & return args & implicit operands.
+f86d65195716 HEAD@{127}: rebase (pick): updated suggesting/coloring of call & return args & implicit operands
+3002813063a8 HEAD@{128}: rebase (pick): --changed Sugesting colors for method calls/return values etc.
+7bdf5ba01bb0 HEAD@{129}: rebase (pick): fixed a coalscing bug
+7524a1746083 HEAD@{130}: rebase (pick): Add library
+ba28b47cb919 HEAD@{131}: rebase (pick): Be const correct
+1aa4098bafea HEAD@{132}: rebase (pick): Minor code cleanups
+629281c4710d HEAD@{133}: rebase (pick): Add cast_or_null & dyn_cast_or_null
+24c3a0a84fda HEAD@{134}: rebase (pick): Implement initializers for structs and pointers
+2f93ba463315 HEAD@{135}: rebase (pick): Rename ConstPoolPointerReference to ConstPoolPointerRef - My fingers get tired typing that much
+e58844e57ecb HEAD@{136}: rebase (pick): Improve error messages on assertion failure.
+73eab57ce304 HEAD@{137}: rebase (pick): * getExitNode() doesn't exist in method anymore
+171cd5f1d612 HEAD@{138}: rebase (pick): Added Instrumentation subdirectory.
+2423a863e15b HEAD@{139}: rebase (pick): Implement global variables. Struct and Pointer initializers are not implemented yet though
+3af979135686 HEAD@{140}: rebase (pick): Implement linking of global variable constant references
+c1129719df3c HEAD@{141}: rebase (pick): Add some more interesting test cases for the linker
+23ab0f2c31f9 HEAD@{142}: rebase (pick): Oops, didn't handle hex values correctly. :(
+c39415b7c1cd HEAD@{143}: rebase (pick): * Fix the constpoolarray -> c"" printing routines to escape things properly
+eb2b5e2b34dd HEAD@{144}: rebase (pick): *** empty log message ***
+a28f8e125258 HEAD@{145}: rebase (pick): Minor cleanup
+131d908673ef HEAD@{146}: rebase (pick): *** empty log message ***
+c11c83a339c8 HEAD@{147}: rebase (pick): Implement linker. It's 95% working now.
+30fa72c1feb8 HEAD@{148}: rebase (pick): More interesting testcase
+5a055ed280fd HEAD@{149}: rebase (pick): Forward operands into implicit uses as well as explicit ones.
+eab25baceb5b HEAD@{150}: rebase (pick): External methods shouldn't have argument lists
+f2bd12a6d988 HEAD@{151}: rebase (pick): Update comment, remove misleading method
+67bb9adc5a0f HEAD@{152}: rebase (pick): Initializers are not const even if the GV is.
+c3d3c0630d9d HEAD@{153}: rebase (pick): Add a new -d argument to dump the internal rep as assembly.
+a7b34ac799ce HEAD@{154}: rebase (pick): Cast NULL when requested.
+731d883c3187 HEAD@{155}: rebase (pick): Added getEntryNode() and getExitNode() functions.
+0003ef936aab HEAD@{156}: rebase (pick): Insert code to trace values at basic block and method exits.
+a4927eee849c HEAD@{157}: rebase (pick): Insert code to trace values at basic block and method exits.
+59a501e47f06 HEAD@{158}: rebase (pick): Added routine to create a char array for a string.
+f3328d15f543 HEAD@{159}: rebase (pick): Added routine to create a char array for a string.
+1b48aa670b0f HEAD@{160}: rebase (pick): Enable most tests.
+b578289a8fa8 HEAD@{161}: rebase (pick): Added a string global variable.
+86d5a822efcc HEAD@{162}: rebase (pick): Two bug fixes that were suppressing some "load-constant-into-register" instrs.
+ae10fbb5bb27 HEAD@{163}: rebase (pick): Move the burg file to here. Add .in suffix to indicate that it gets
+42fcb2d89630 HEAD@{164}: rebase (pick): Make the sparc.burg file be a little more flexible and rubust in the fact of
+e5eb3fe6f018 HEAD@{165}: rebase (pick): Use the instruction.def file to remain up to date with future instruction
+a95ca89e8976 HEAD@{166}: rebase (pick): New file to define instructions...
+1a9806113e30 HEAD@{167}: rebase (pick): Burg files should come out of the Debug Directory for temporary files
+a1012b17f9a7 HEAD@{168}: rebase (pick): New module linking functionality prototype
+5726d1d2ecd4 HEAD@{169}: rebase (pick): Check in makefile
+bfc372b3a5a3 HEAD@{170}: rebase (pick): Fixed tags target so it only happens at root level.
+ad26264a523c HEAD@{171}: rebase (pick): Add C source for testmisc.ll
+9c5a5f970837 HEAD@{172}: rebase (pick): Dang, I screwed up the merge. This should be better
+db6e9ecc453f HEAD@{173}: rebase (pick): New testcase for testing constant pointers to globals
+5eff5faafba2 HEAD@{174}: rebase (pick): Test files for linker
+77a7c277d54d HEAD@{175}: rebase (pick): MethodTypes take an explicit isVarArg argument
+19293514b699 HEAD@{176}: rebase (pick): Fix comment flyer
+684125529570 HEAD@{177}: rebase (pick): Add new linker
+cff52fd4a48a HEAD@{178}: rebase (pick): Build the new linker
+cba92a5489f2 HEAD@{179}: rebase (pick): Use null keyword instead of kludge
+42c3881f4c41 HEAD@{180}: rebase (pick): Add more function call and prototype specific tests
+c82370afa049 HEAD@{181}: rebase (pick): Compile the transforms directory
+6dad439c635a HEAD@{182}: rebase (pick): Start of a linker
+71585a57f2b0 HEAD@{183}: rebase (pick): Implement the invoke instruction
+4aac971feb66 HEAD@{184}: rebase (pick): * Fix a nefarious bugs: TypesEqual was wrong for varargs methods
+81374f6531a5 HEAD@{185}: rebase (pick): Convert a runtime check into an assertion
+fc856307fe9a HEAD@{186}: rebase (pick): * Add support for Module specific constants
+5119ee94dd54 HEAD@{187}: rebase (pick): Add new TerminatorInst ctor for invoke
+97aceab30ca0 HEAD@{188}: rebase (pick): * Fix TODO
+fdd33fff63c6 HEAD@{189}: rebase (pick): Fix broken #endif
+6eab48b3c68d HEAD@{190}: rebase (pick): * Add #include
+d64929f66211 HEAD@{191}: rebase (pick): Add StringList support
+d5f1339c1461 HEAD@{192}: rebase (pick): Support the invoke instruction
+362b89b2697e HEAD@{193}: rebase (pick): Support indirect calls
+250990a3ef85 HEAD@{194}: rebase (pick): not is a keyword in ansi C++, avoid it
+cad98049b01e HEAD@{195}: rebase (pick): * Fix privacy issues on RegToRefVecMap
+6d8a50fb7185 HEAD@{196}: rebase (pick): * Use new style casts more
+d5ef68f42b47 HEAD@{197}: rebase (pick): * Add real support for global variable addresses initializing constants
+5b89a0710636 HEAD@{198}: rebase (pick): * Support writing GlobalVariables with info comments by them
+38600d48ce25 HEAD@{199}: rebase (pick): * Add support for forward references of global variable addresses
+30567de7ef54 HEAD@{200}: rebase (pick): Add operator< to ValID's so that they can be put in map's
+c4253f651f13 HEAD@{201}: rebase (pick): Remove exception specification
+e46a527bd890 HEAD@{202}: rebase (pick): Support the new Invoke instruction
+dbf3974c7876 HEAD@{203}: rebase (pick): Support pointers to globals happily
+f72067424d95 HEAD@{204}: rebase (pick): Fix code to make GCC 2.96 happy
+ec668ae234aa HEAD@{205}: rebase (pick): * Add support for Invoke instructions
+b92a0735743c HEAD@{206}: rebase (pick): Fix filename in comment
+eac143eefddc HEAD@{207}: rebase (pick): Better linux support. This file still sucks
+98503c7ebc77 HEAD@{208}: rebase (pick): Fix broken #endif
+ca3d924e3846 HEAD@{209}: rebase (pick): not is a keyword in Ansi C++. Avoid it
+c168bc53e09e HEAD@{210}: rebase (pick): Clean up initializers for GCC 2.96
+b54fa1a20171 HEAD@{211}: rebase (pick): Remove exception specification. Only slows code down.
+ed95b6657e6b HEAD@{212}: rebase (pick): Changes to compile with GCC 2.96
+c22edf4bc5a2 HEAD@{213}: rebase (pick): Add comment indicating semantics of indirect calls
+4dcafac17dcb HEAD@{214}: rebase (pick): New ctor for invoke inst
+a8a651345904 HEAD@{215}: rebase (pick): Add support for indirect calls
+af0d7630a30d HEAD@{216}: rebase (pick): Add some casts to make GCC 2.96 happy.
+868db5e40c09 HEAD@{217}: rebase (pick): Add use_back() methods
+08696c9b3a19 HEAD@{218}: rebase (pick): Add classof implementations for User
+3776f284eb1a HEAD@{219}: rebase (pick): Expose typedefs
+d5660029e7f9 HEAD@{220}: rebase (pick): Add support for module local constants
+8f28f49eecf5 HEAD@{221}: rebase (pick): Add new opcode for Invoke instruction
+c6c0d280af0b HEAD@{222}: rebase (pick): Minor changes, add new ctor for invoke instruction
+f230dca276c8 HEAD@{223}: rebase (pick): Add assertions
+c4ea40ffae4f HEAD@{224}: rebase (pick): * Minor Formatting changes.
+e4f89d5176af HEAD@{225}: rebase (pick): * Add destroyConstant stuff to handle module local constants
+0a73f5e2e880 HEAD@{226}: rebase (pick): Update todo's
+b66fb116fe18 HEAD@{227}: rebase (pick): Each tools should not make tags
+969240424993 HEAD@{228}: rebase (pick): --corrected coalescing test: coalsed only if two are of the same reg class
+54622d353dc1 HEAD@{229}: rebase (pick): added support for implict operands in machine instruction
+af225afe483a HEAD@{230}: rebase (pick): --added support for implicit operands in machine instructions
+4c1eeb2f0207 HEAD@{231}: rebase (pick): Delete *.s on clean.
+e0e2c0de0d59 HEAD@{232}: rebase (pick): Record implicitRefs for each machine instruction instead of
+c7344856e2e2 HEAD@{233}: rebase (pick): Add graph edges due to implicit refs in each machine instruction.
+da6e725984b0 HEAD@{234}: rebase (pick): Added a rule for building TAGS.
+84249865be76 HEAD@{235}: rebase (pick): Repeat some libs due to circular dependences between Sparc and other
+b41937df9bac HEAD@{236}: rebase (pick): Don't insert useful instructions in delay slot of a RETURN.
+8ec3840fd358 HEAD@{237}: rebase (pick): Insert code to load constants used as Call or Return arguments.
+dfb65425ee14 HEAD@{238}: rebase (pick): Machine-independent code generation routines used in instruction
+e8a1ea03539a HEAD@{239}: rebase (pick): Moved code generation support routines to InstrSelectionSupport.{h,cpp}.
+920028cc0b2f HEAD@{240}: rebase (pick): Moved code generation support routines to InstrSelectionSupport.cpp.
+362badd47ffe HEAD@{241}: rebase (pick): Moved first function to "simpleadd.ll".
+e3a87d5e89a0 HEAD@{242}: rebase (pick): testmemory and sumarray now work with instruction selection.
+a08813e66ef9 HEAD@{243}: rebase (pick): --removed %g regs being allocated - fix later
+576355e82463 HEAD@{244}: rebase (pick): Add hack to get rid of malloc & free instructions for code generation
+5566f9c03615 HEAD@{245}: rebase (pick): Add comment
+704887cc1858 HEAD@{246}: rebase (pick): Support multiple global's definitions
+97e5c873483d HEAD@{247}: rebase (pick): Factor parentness out of Module & GlobalVariable into GlobalValue
+370c4a28a876 HEAD@{248}: rebase (pick): Rename getNullPointer to getNull
+ddfe3ae972ff HEAD@{249}: rebase (pick): Rename getNullPointer to getNull
+7b0ee1e797ab HEAD@{250}: rebase (pick): Allow duplicate constant values as long as they are compatible.
+a13bc1844828 HEAD@{251}: rebase (pick): Share ConstPoolPointer elements correctly
+bd8752038e30 HEAD@{252}: rebase (pick): Fix broken testcase
+398a1a5573f9 HEAD@{253}: rebase (pick): Add check to make sure that we dont reference MEthodType's directly
+bdb349a55426 HEAD@{254}: rebase (pick): * Both Method & GlobalVariable now subclass GlobalValue
+5c22b0d643af HEAD@{255}: rebase (pick): Adjust test cases to match the fact that methods are now explicit pointer values, not explicit
+1f92e9fc5d90 HEAD@{256}: rebase (pick): First try at a horrible global value reference wrapper
+ebf7f8fa07e7 HEAD@{257}: rebase (pick): Clean up parser, fix a bug that prevented this from working:
+eedd6c7c8622 HEAD@{258}: rebase (pick): * Add support for null as a constant
+550de7f1b919 HEAD@{259}: rebase (pick): Modify testcases for new LLVM const syntax
+dfe6c7e0aff1 HEAD@{260}: rebase (pick): Commit more code over to new cast style
+8d5994a86223 HEAD@{261}: rebase (pick): Convert more code to use new style casts
+22c53dc308b0 HEAD@{262}: rebase (pick): Add more support for new style casts
+e876f00ebb60 HEAD@{263}: rebase (pick): Add support for new style casts
+0b735821091f HEAD@{264}: rebase (pick): Add support for newer cleaner isa, cast, dyn_cast
+8f546a6b1eb9 HEAD@{265}: rebase (pick): Update comments
+154b8c0b0bdb HEAD@{266}: rebase (pick): Pull predecessor and successor iterators out of the CFG*.h files, and plop them into
+96bfa8db5614 HEAD@{267}: rebase (pick): Pull predecessor and successor iterators out of the CFG*.h files, and plop them into
+0c5cd66015ba HEAD@{268}: rebase (pick): Comment out a paragraph that refers to a file that no longer exists
+bf9adf15ad50 HEAD@{269}: rebase (pick): Fix emission of return instructions
+af1ab310689d HEAD@{270}: rebase (pick): Add path to as so it doesn't find llvm as if that path is set.
+554b4bc20205 HEAD@{271}: rebase (pick): Exclude a couple of tests that the regalloc stuff doesn't handle yet
+2d6c6b32a60e HEAD@{272}: rebase (pick): Add 
diff erent "cast constant value" for several possible types.
+5a0bdbf41700 HEAD@{273}: rebase (pick): Add vector `implicitUses' to class MachineCodeForVMInstr to hold values
+69e68114634e HEAD@{274}: rebase (pick): Several fixes:
+ecfd19aa7a65 HEAD@{275}: rebase (pick): removing phy regaloc - incorrect file
+c9899c19a917 HEAD@{276}: rebase (pick): Change latency of setuw and setsw to 2 cycles.
+8e03b2d97f34 HEAD@{277}: rebase (pick): Change ! ( ...== ...) to !=.
+aa06d6438043 HEAD@{278}: rebase (pick): Improved dump for disp type operand.
+d09bbd3e62ee HEAD@{279}: rebase (pick): Bug fixes:
+4542845ffac4 HEAD@{280}: rebase (pick): Minor changes for bug fixes in SchedGraph.cpp.
+f2d34339b43a HEAD@{281}: rebase (pick): Two bug fixes:
+dadedae23021 HEAD@{282}: rebase (pick): *** empty log message ***
+e30f6b836af1 HEAD@{283}: rebase (pick): no major change.
+17745bb05c7a HEAD@{284}: rebase (pick): added suggesting color support
+0c5afc6b26f2 HEAD@{285}: rebase (pick): added suggesting color suppor
+bdaab1203288 HEAD@{286}: rebase (pick): added support for suggesting colors
+3061d7a1e42b HEAD@{287}: rebase (pick): --added suggesting colors; call/ret arg handling
+f3d3eee7e06a HEAD@{288}: rebase (pick): Add a test for the new null keyword
+8e9b70834fa4 HEAD@{289}: rebase (pick): Implement constant pointers, and null specifically in the parser, bytecode writer, and
+d20cd6b4422b HEAD@{290}: rebase (pick): Implement a constant pointer value
+91bf6d53e2e8 HEAD@{291}: rebase (pick): Pull iterators out of CFG.h and genericize them with GraphTraits
+1f5ff53527ab HEAD@{292}: rebase (pick): File #include file
+60f364cc5b13 HEAD@{293}: rebase (pick): Pull iterators out of CFG.h and CFGdecls and put them in Support directory
+ab4adf7cba15 HEAD@{294}: rebase (pick): * Properly escape function names
+b329ccfca12b HEAD@{295}: rebase (pick): Check in bug fix for vadve
+3eaa426db4d4 HEAD@{296}: rebase (pick): Add commands to assemble and compile a .ll file
+0fd9a3dcc702 HEAD@{297}: rebase (pick): Initial support for construction of a call graph
+b3a3ecaf05f7 HEAD@{298}: rebase (pick): Add support to print a call graph, and also add support for module level interprocedural analyses
+464bdb4b73aa HEAD@{299}: rebase (pick): Adding the tool to the path doesn't break anything anymore
+f1f7f171a7a5 HEAD@{300}: rebase (pick): Make error report a little more useful
+58d981ac2a15 HEAD@{301}: rebase (pick): ADCE is broken but at least we know why
+dae33afb6ab1 HEAD@{302}: rebase (pick): print out value's by pointer
+cb586b4aa067 HEAD@{303}: rebase (pick): Add capability to print out call graph
+24c1bbab59ca HEAD@{304}: rebase (pick): Global variables/complex constants have been resolved!
+4d13ee0a9344 HEAD@{305}: rebase (pick): -- fixed a ret val bug
+19f2d28d3fb2 HEAD@{306}: rebase (pick): -- removed debugging messages
+d23e458745cb HEAD@{307}: rebase (pick): -fixed return value bug.
+b53ab66b2055 HEAD@{308}: rebase (pick): Add proper support to send output to the right place
+1da35ac9ce16 HEAD@{309}: rebase (pick): Print .def files as well as other files
+1a7c20d822d2 HEAD@{310}: rebase (pick): Change debug info from #define to command line option
+bdd630363635 HEAD@{311}: rebase (pick): Change debug info from #define to command line option
+d27bcdc4d564 HEAD@{312}: rebase (pick): * REMOVE extraneous debug info if DEBUG_RA is not set
+b58b0442c078 HEAD@{313}: rebase (pick): Seperate instruction definitions into new SparcInstr.def file
+84ba33c8b41a HEAD@{314}: rebase (pick): Okay, make the member function work.
+c14992951e06 HEAD@{315}: rebase (pick): Remove global debug output fns that have been superceded by a member func
+78a5c492e944 HEAD@{316}: rebase (pick): Remove debugging output stuff
+3f14f79d64e6 HEAD@{317}: rebase (pick): Emit assembly language from the target...
+5a780fe743b5 HEAD@{318}: rebase (pick): Add emitAssembly Method
+6d1bd8d21e41 HEAD@{319}: rebase (pick): Add idea
+f821fceb8d6a HEAD@{320}: rebase (pick): Add EmitAssembly to mf
+d2ccd8e344fc HEAD@{321}: rebase (pick): First cut at assembly output
+7cd873804115 HEAD@{322}: rebase (pick): Add emitAssemblyMethod to TargetMachine
+8749075054d9 HEAD@{323}: rebase (pick): *** empty log message ***
+ca4aeed4cda6 HEAD@{324}: rebase (pick): --added methods to operand class to set/get registers after register allocation
+d3262f97ed7a HEAD@{325}: rebase (pick): -- ruchira
+983537f3112b HEAD@{326}: rebase (pick): -- updated printing
+df8fc0fcada5 HEAD@{327}: rebase (pick): Remove a copy of a bunch of code
+5ff0c9da9f43 HEAD@{328}: rebase (pick): C++ gives us auto_ptr's, so we might as well use them. :)
+0a6274f4f469 HEAD@{329}: rebase (pick): Fix up code a bit, remove operator<< to Assembly/Writer.h
+8ebd15ef9e5b HEAD@{330}: rebase (pick): Remove extraneous #includes
+992e6cf11454 HEAD@{331}: rebase (pick): Move operator << from Value.h to Assembly/Writer.h
+05c03e0a4a43 HEAD@{332}: rebase (pick): Remove operator << to Assembly/Writer.h
+32354c42e162 HEAD@{333}: rebase (pick): Don't check for null on delete
+348cbcb3414c HEAD@{334}: rebase (pick): Un-neuter makefile
+b9015643ae16 HEAD@{335}: rebase (pick): Minor changes.
+31eddde1fbe7 HEAD@{336}: rebase (pick): Folded inssel*.ll into select.ll.
+93a7445ced49 HEAD@{337}: rebase (pick): Renamed files to match the primary classes they provide.
+73a5ca83c073 HEAD@{338}: rebase (pick): Renamed a header file.
+116c6caa7247 HEAD@{339}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+4fc2bc116a7f HEAD@{340}: rebase (pick): Allow pointer constants as well as integer and booleans.
+4350d1b2f431 HEAD@{341}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+c3645e342ca4 HEAD@{342}: rebase (pick): Renamed files to match the main classes they provide.
+2221c6a54d56 HEAD@{343}: rebase (pick): Cast unsigned to int! It was causing a nice little bug.
+3692872402ab HEAD@{344}: rebase (pick): Minor changes.
+fdf7be61f2e0 HEAD@{345}: rebase (pick): Don't add instructions to subtree for Phi or Call.
+c5ec3128e60a HEAD@{346}: rebase (pick): Format file header.
+9bce80700742 HEAD@{347}: rebase (pick): Add new entry/exit edges when removing delay slot nodes from the graph.
+0c5c4e8dfb45 HEAD@{348}: rebase (pick): Moved erase edge functions to class SchedGraph.
+ad74a2f916dd HEAD@{349}: rebase (pick): Renamed some header files.
+6f280562c6f1 HEAD@{350}: rebase (pick): Moved erase-edge functions from SchedGraphNode to SchedGraph.
+c20d754ef692 HEAD@{351}: rebase (pick): Moved DebugValue to Value.cpp.
+a18896cb69d9 HEAD@{352}: rebase (pick): Added debugging support.
+b99a5873a966 HEAD@{353}: rebase (pick): Moved debugging interfaces for class Value to Value.h.
+de14aceb2e19 HEAD@{354}: rebase (pick): Minor fixes: renamed target machine files; fold sched info into TargetMachine.
+1fabb8f4d05b HEAD@{355}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+004e1e8c9bd5 HEAD@{356}: rebase (pick): Added debugging support.
+5308e6f9d6ca HEAD@{357}: rebase (pick): Fix testcases to handle new syntax for construction and initializeation
+23bc63990bca HEAD@{358}: rebase (pick): Remove the unsized array constraint
+23b021feb086 HEAD@{359}: rebase (pick): Add support for global constants, and for initializers for constants
+1f2803d9c6b3 HEAD@{360}: rebase (pick): Add support for global constants, and for initializers for constants
+e1fed6f079c9 HEAD@{361}: rebase (pick): added a method to get reg num after register allocation
+ae7bbf4710cc HEAD@{362}: rebase (pick): modified machine code printing
+13af7a7caac6 HEAD@{363}: rebase (pick): -modified machine operand class - took regNum out of union to set regNum after
+6bddc120b229 HEAD@{364}: rebase (pick): modified printing of debug messages
+313c2a193181 HEAD@{365}: rebase (pick): --added methods for printing
+b8916ea9dfc9 HEAD@{366}: rebase (pick): added setRegForValue to MachineOperand class
+072b09e468f8 HEAD@{367}: rebase (pick): fixed printing messages
+357bf235defd HEAD@{368}: rebase (pick): -- debug messages dissabled
+b3a9794066b2 HEAD@{369}: rebase (pick): added reg alloc support
+4ac010f69361 HEAD@{370}: rebase (pick): --reg alloc code added
+c7e1696e212a HEAD@{371}: rebase (pick): -reg alloc code
+74fe0add218c HEAD@{372}: rebase (pick): added register allocation code
+1c1d5b77ea72 HEAD@{373}: rebase (pick): Added regalloc
+261723120208 HEAD@{374}: rebase (pick): Oops, accidentally checked my debugging makefile
+ccba943ebd24 HEAD@{375}: rebase (pick): Fix a bug with not removing method level types after compilation
+32436a343662 HEAD@{376}: rebase (pick): added RegAlloc Directory to DIRS
+1c24930f9da4 HEAD@{377}: rebase (pick): *** empty log message ***
+cac3722a15a8 HEAD@{378}: rebase (pick): *** empty log message ***
+c6554b4537c1 HEAD@{379}: rebase (pick): Remove invalid testcase
+847094903baa HEAD@{380}: rebase (pick): Remove invalid testcase. Unneccesary anyways
+d71ff5c79c96 HEAD@{381}: rebase (pick): Add new test cases
+7789d9c7f54d HEAD@{382}: rebase (pick): Add support for loading and storing pointers...
+a3aa024f5831 HEAD@{383}: rebase (pick): Fix a bug that caused a crash if a setcc had zero uses.
+c70348cb828c HEAD@{384}: rebase (pick): Add a forward decl, oops.
+85c86566e9a5 HEAD@{385}: rebase (pick): Chris seems fond of #include <vector>. Fix these. Also convert use list in
+3edb0d2e080e HEAD@{386}: rebase (pick): Add a comment
+5c8a3647ccb6 HEAD@{387}: rebase (pick): Minor reformatting, & protection fixes
+ec87fa4f8523 HEAD@{388}: rebase (pick): Break scheduling infrastructure out of TargetMachine.cpp into SchedInfo.cpp
+d589bb98df47 HEAD@{389}: rebase (pick): Split Register specific stuff out from TargetMachine.h to RegInfo.h
+ec018be202c8 HEAD@{390}: rebase (pick): Split Target/Machine.h into three files:
+53bcc4463c09 HEAD@{391}: rebase (pick): Make a new llvm/Target #include directory.
+aaca226978d7 HEAD@{392}: rebase (pick): Checkin changes to:
+9cec2d47b443 HEAD@{393}: rebase (pick): Checkin changes to:
+3b15eb471b31 HEAD@{394}: rebase (pick): Move files to new sparc directory
+11954336afe2 HEAD@{395}: rebase (pick): Move the sparc target to a new lib/Target directory
+a8d3715d2038 HEAD@{396}: rebase (pick): Move files.
+82cb584aec3c HEAD@{397}: rebase (pick): Move the contents of the CodeGen/TargetMachine/Sparc directory to Target/Sparc
+1799226a9df7 HEAD@{398}: rebase (pick): This checkin represents some cleanup of the backend, implementing the following things:
+2153a7e280f6 HEAD@{399}: rebase (pick): This checkin represents some cleanup of the backend, implementing the following things:
+9936a71b49ba HEAD@{400}: rebase (pick): Updates to use local header files.
+ddef6185b427 HEAD@{401}: rebase (pick): Export the instruction forest support from the analysis library
+44e4e80c2911 HEAD@{402}: rebase (pick): Initial instruction tree support for the analysis library
+001ff12fbe1c HEAD@{403}: rebase (pick): Generic k-way tree support
+015b075f7f69 HEAD@{404}: rebase (pick): More cleanups, preparing to revamp InstrForest to, among other things,
+d6c5ea5c2392 HEAD@{405}: rebase (pick): * Clean up InstrForest
+8f70795fa947 HEAD@{406}: rebase (pick): Eliminate 'BasicNode' from InstrForest.
+02e210b78442 HEAD@{407}: rebase (pick): Eliminate MainTreeNode function
+bacc3815ee3a HEAD@{408}: rebase (pick): Remove irrelevant gross K&R Cisms
+99dec15bddc1 HEAD@{409}: rebase (pick): Handle subtract in expression classifier
+9c9d9777ee76 HEAD@{410}: rebase (pick): Disable destructors on constants
+58b30135c56a HEAD@{411}: rebase (pick): Use the correct style casts
+6fb05a7fb6f1 HEAD@{412}: rebase (pick): Use correct style casts
+f6d78c00b28d HEAD@{413}: rebase (pick): Use correct style casts
+bd9287aa5602 HEAD@{414}: rebase (pick): Use type checking predicates
+b760399acaf2 HEAD@{415}: rebase (pick): Use correct casts
+86f6acb766bb HEAD@{416}: rebase (pick): Use predicate for Value type test
+b1223a7dc00c HEAD@{417}: rebase (pick): Use predicate for Value type test
+5dbd964b9fbc HEAD@{418}: rebase (pick): ModuleTyID doesn't exist anyymore
+c583d68d95f8 HEAD@{419}: rebase (pick): getMethodType is now just getType
+862b2212c267 HEAD@{420}: rebase (pick): Add support for printing globals
+9815c0143466 HEAD@{421}: rebase (pick): Update to use correct type cast
+4ebfeafd5ae2 HEAD@{422}: rebase (pick): Add support for global variables
+7309e89eeead HEAD@{423}: rebase (pick): * Add capability of printing out a global variable
+332d403bc73d HEAD@{424}: rebase (pick): * Method::getType should return type cast as MethodType, eliminate getMethodType
+09b1c8b53b5b HEAD@{425}: rebase (pick): Update assertion to allow extra case
+c9f650f82da6 HEAD@{426}: rebase (pick): Fix a bug I introduced (assertion failed: Unknown operand type), and convert to predicate style for type checks
+ca665a4f7301 HEAD@{427}: rebase (pick): Implement global variable support
+78c27fc8588b HEAD@{428}: rebase (pick): Add support for external methods
+3b4968db64d9 HEAD@{429}: rebase (pick): Genericize support for calling functions a bit
+f2292a6f5bef HEAD@{430}: rebase (pick): Add support for tool specified linker options
+e7d26918d539 HEAD@{431}: rebase (pick): Remove the definitions of 3 global functions that don't belong in the core
+3268cb00c3aa HEAD@{432}: rebase (pick): Implement the subset of the GetConstantValueAsSignedInt function that is needed, locally. Remove the two support functions to inline their contents.
+5ce25378872d HEAD@{433}: rebase (pick): Implement the subset of the GetConstantValueAsSignedInt function that is needed, locally.
+7f1dfe6c75ba HEAD@{434}: rebase (pick): Remove 3 gross global functions that don't belong here
+bcfd7d3b4a2f HEAD@{435}: rebase (pick): Rename contype to subtype
+925282156193 HEAD@{436}: rebase (pick): Make ADCE more robust, it still has problems, but it's getting closer
+a8aa73f44e44 HEAD@{437}: rebase (pick): Fix problems with freeing memory twice
+3e58e695c052 HEAD@{438}: rebase (pick): Rename file to be consistent with header name
+45093beca645 HEAD@{439}: rebase (pick): Rerun backend tests if as or llc is changed
+920978127ffb HEAD@{440}: rebase (pick): iFix dependence order
+0dda5dffe9e1 HEAD@{441}: rebase (pick): Clean up Type class by removing mutable ConstRules member and use annotations insead
+8926543a23ba HEAD@{442}: rebase (pick): Clean up ConstRules stuff to use annotations instead of a mutable member in Type
+0554a9254254 HEAD@{443}: rebase (pick): Convert ConstRules to use annotations to clean it up.
+ae70148c0e33 HEAD@{444}: rebase (pick): Fix automatic dependence on static libs
+57a4461c8737 HEAD@{445}: rebase (pick): Handle cast float-to-float or cast double-to-double.
+e26d17b941c6 HEAD@{446}: rebase (pick): Fix build breakage. :(
+468369dd37c3 HEAD@{447}: rebase (pick): I really don't like it when people break the build.
+093db3f2c28b HEAD@{448}: rebase (pick): Remove extraneous space
+d7fa14961741 HEAD@{449}: rebase (pick): Remove extra #include
+13c90b0c405c HEAD@{450}: rebase (pick): *** empty log message ***
+ad0e744b8800 HEAD@{451}: rebase (pick): *** empty log message ***
+479d6ea91cea HEAD@{452}: rebase (pick): Committed for compliation. Not yet final.
+3e3b370cfca9 HEAD@{453}: rebase (pick): --Ruchira
+215ca905feb5 HEAD@{454}: rebase (pick): New testcase to deal with lists
+91c3618d9fba HEAD@{455}: rebase (pick): New file for supporting abstract types
+d0201e668537 HEAD@{456}: rebase (pick): Make use of the new TOOLNAME/USEDLIBS options provided in Makefile.common
+edadb7525ef9 HEAD@{457}: rebase (pick): Executables all live in a nice centralized location now
+a461b8412da2 HEAD@{458}: rebase (pick): Executables have moved into centralized location
+f02709b9d7a9 HEAD@{459}: rebase (pick): Support TOOLNAME and USEDLIBS options for easier tool building
+e41581d43385 HEAD@{460}: rebase (pick): Remove old old file
+cb93b76e7fdc HEAD@{461}: rebase (pick): Convert llc driver to standard tool format
+cb8ea37f651a HEAD@{462}: rebase (pick): Provide a way to change the incoming value for a phi node
+21daac648d0a HEAD@{463}: rebase (pick): Add llc path to setup
+a3f8c0135396 HEAD@{464}: rebase (pick): Uhm... that was really bad
+a428778af63a HEAD@{465}: rebase (pick): Clean up driver
+545e4d0d6342 HEAD@{466}: rebase (pick): Make makefile not depend on where stuff is installed!!!!
+63fb58422942 HEAD@{467}: rebase (pick): Updates to work with new lack of constant pool
+d08a74d2397c HEAD@{468}: rebase (pick): Remove unneeded #includes
+17ba4b1a7377 HEAD@{469}: rebase (pick): Remove unnecesary #include add dump calls pulled out of .h file
+4baa9c258dc7 HEAD@{470}: rebase (pick): * Remove lots of #includes
+5fbff64a9093 HEAD@{471}: rebase (pick): * Remove lots of unnecesary #includes
+fa24fc193248 HEAD@{472}: rebase (pick): * Remove lots of annoying extra #includes
+4a1115871ab1 HEAD@{473}: rebase (pick): * Add tag so emacs knows it's a c++ file
+aa1f51a47db4 HEAD@{474}: rebase (pick): Add tags so emacs knows these are C++ files
+66cdfde08ddd HEAD@{475}: rebase (pick): Remove extra space
+df7b57cb2016 HEAD@{476}: rebase (pick): Remove ReversePostOrderTraversal declaration
+e182a70686df HEAD@{477}: rebase (pick): * Don't predefine ReversePostOrderTraversal because it adds a dependence on vector
+a7b751de9148 HEAD@{478}: rebase (pick): Check opaque, abstract, and recursive type handling
+f65fc4c4b0ca HEAD@{479}: rebase (pick): NEw file
+f5797eee291e HEAD@{480}: rebase (pick): Moved functionality into the other constant pool stuff
+c317aff403de HEAD@{481}: rebase (pick): Follow the golden rule of the coding standards guide: Make the code look
+228b2301a5b8 HEAD@{482}: rebase (pick): The header file for a translation unit should always be included first
+ec28d6b33de6 HEAD@{483}: rebase (pick): A file should always include it's private header file *FIRST* see the
+a4fd66e4bb44 HEAD@{484}: rebase (pick): Constant pool is eliminated
+895e8966aaf7 HEAD@{485}: rebase (pick): Add support for iteration through type graphs
+1bc1a1e55811 HEAD@{486}: rebase (pick): Remove support for const pool merging, which is obsolete now.
+1f68aecd491b HEAD@{487}: rebase (pick): Annotations are now const
+aa592d53a869 HEAD@{488}: rebase (pick): Build lli first
+a7352c105c5a HEAD@{489}: rebase (pick): Symboltables are sorted in the bytecode, so no problems here!
+5fdc17bb41c2 HEAD@{490}: rebase (pick): Cleanup
+98cf8e526cfc HEAD@{491}: rebase (pick): Support abstract types
+e64122141c47 HEAD@{492}: rebase (pick): Support a abstract, opaque, and recursive types
+299db7ad37f6 HEAD@{493}: rebase (pick): Types and constnats are wierd objects in the symtabs
+391ecb41103e HEAD@{494}: rebase (pick): Modules must have a valid, nonnull type. Make them void
+186d4233d066 HEAD@{495}: rebase (pick): Support new setName interface
+7339777dc091 HEAD@{496}: rebase (pick): * Support new setname interface
+ba310ef38dcf HEAD@{497}: rebase (pick): * Cnstants are now global objects
+05ef1117f8d2 HEAD@{498}: rebase (pick): Support new setName itf
+3d922776af3d HEAD@{499}: rebase (pick): Annotations are const objects now
+3ad5e85b0e7c HEAD@{500}: rebase (pick): Types and constants are wierd things in symbol tables now
+e95eeb238191 HEAD@{501}: rebase (pick): * Eliminate reference to ConstantPool class
+69013e51442c HEAD@{502}: rebase (pick): Constant pool is dead
+6aabf9bb8d09 HEAD@{503}: rebase (pick): Constants are now global unique objects
+5eccfe8f4744 HEAD@{504}: rebase (pick): * Eliminate constant pool dependancies:
+116bd1f60c7d HEAD@{505}: rebase (pick): * Supoprt global constants
+719ec15e3bca HEAD@{506}: rebase (pick): * Support global constants
+3e22e6fbc35c HEAD@{507}: rebase (pick): annotations are now const
+94469c594e8f HEAD@{508}: rebase (pick): * Emit bytecode using a deque instead of a vector to be faster
+cd31dfffe14a HEAD@{509}: rebase (pick): * Remove support for internal constant pool
+0ccb4914c583 HEAD@{510}: rebase (pick): * Assembly writer is not a module analyzer anymore
+81be60efae5b HEAD@{511}: rebase (pick): * Add support for forward referencing types
+92f9faa8cd41 HEAD@{512}: rebase (pick): Add support for forward referencing types
+7cb39bcc9b11 HEAD@{513}: rebase (pick): Add support for an opaque type
+0cc953a4eb36 HEAD@{514}: rebase (pick): Remove #include of nonexistant header file
+e659434201e7 HEAD@{515}: rebase (pick): * Slot calc is now simpler and not based on module analyzer.
+d9953427123b HEAD@{516}: rebase (pick): Module analyzer no longer has to iterate over constant pool
+59b2b4978c66 HEAD@{517}: rebase (pick): Simplify code by eliminating need to hang onto constant pool references
+ca915a915738 HEAD@{518}: rebase (pick): * Fixed mapped_iterator to actually work with functors
+db2d5ad6fc13 HEAD@{519}: rebase (pick): Constant pools no longer exist
+e6503b4355e7 HEAD@{520}: rebase (pick): Eliminate DoConstantPoolMerging. ConstantPools no longer exist
+8e819e87f9aa HEAD@{521}: rebase (pick): You no longer have to delete constants! They are located in a global
+9e1456843e33 HEAD@{522}: rebase (pick): Annotations are now passed around as const objects
+37781e4265d3 HEAD@{523}: rebase (pick): Use a deque instead of a vector for greater efficiency writing bytecode
+68b52d48b8d2 HEAD@{524}: rebase (pick): Clean stuff up.
+ef8df94e3aba HEAD@{525}: rebase (pick): Simplify SlotCalculator. SlotCalculator is now not a ModuleAnalyzer
+220b450fb4a8 HEAD@{526}: rebase (pick): Simplify analyzer
+435cda780cfc HEAD@{527}: rebase (pick): * Fix long standing problems that would affect inlining. How could this have worked?
+0cb567d4d189 HEAD@{528}: rebase (pick): Add assertion to check for
+e0ab1c69297f HEAD@{529}: rebase (pick): * Values are AbstactTypeUsers to support abstract types
+16c83b3c1356 HEAD@{530}: rebase (pick): Remove extra whitespace at EOL
+a2e45cbc6285 HEAD@{531}: rebase (pick): * Add support for Opaque & Abstract types.
+875576a6650b HEAD@{532}: rebase (pick): Support abstract types by keeping on the use list of the abstract type.
+70bc7b10091b HEAD@{533}: rebase (pick): SymTabValues no longer hold constant pools
+c3d4689a42cb HEAD@{534}: rebase (pick): SymTabValue no longer includes ValueHolder for Module. Include it ourself
+aefcbb9a7f94 HEAD@{535}: rebase (pick): * Support new setName interface
+22059fea78a8 HEAD@{536}: rebase (pick): Support new setName interface
+30dd0bdb5f35 HEAD@{537}: rebase (pick): * Add new DerivedType base class that goes between Type and the derived types
+fb9e4e1fcdc4 HEAD@{538}: rebase (pick): Implement support for globally unique constants. Constants no longer live
+924247d31d99 HEAD@{539}: rebase (pick): Add support for walking type graphs
+fa3aa419ab9f HEAD@{540}: rebase (pick): Changing setName semantics
+38d0897ea620 HEAD@{541}: rebase (pick): Make annotations operations const with a mutable annotation list so that
+59216be202de HEAD@{542}: rebase (pick): Fixed the "output constant pool even if he have no constants" issue
+ab906331394b HEAD@{543}: rebase (pick): whoo hoo I did something! :)
+628ad7914f58 HEAD@{544}: rebase (pick): Make fib be more real
+e5ad7ea67698 HEAD@{545}: rebase (pick): *** empty log message ***
+147dbdd611ae HEAD@{546}: rebase (pick): *** empty log message ***
+07a717031897 HEAD@{547}: rebase (pick): Added directory LiveVar/
+2b9d47fba512 HEAD@{548}: rebase (pick): Makefile for tools/tests/
+ef1302a7da62 HEAD@{549}: rebase (pick): Driver to test IsPowerOf2. Could be extended for other library routines.
+eb98e995c108 HEAD@{550}: rebase (pick): Add testcodegen target, and restrict which tests are run for it.
+8e434f5bede3 HEAD@{551}: rebase (pick): Added nonterminals for arithmetic operations where one operand is constant.
+8846488b12e7 HEAD@{552}: rebase (pick): Changed link line.
+b9204403813b HEAD@{553}: rebase (pick): Add calls to NormalizeMethod() and to ScheduleInstructionsWithSSA().
+ad0b73970f13 HEAD@{554}: rebase (pick): Makefile for InstrSched/
+03d07894e506 HEAD@{555}: rebase (pick): Remove source list.
+bf1f10e707bf HEAD@{556}: rebase (pick): Added directory InstrSched.
+db25e211611a HEAD@{557}: rebase (pick): Major changes too hard to document :-)
+6195f94883e7 HEAD@{558}: rebase (pick): Added function MachineInstr::operandIsDefined(i) and decl for
+4aa6182a26f1 HEAD@{559}: rebase (pick): Extensive additions for supporting instruction scheduling.
+21aba4339c60 HEAD@{560}: rebase (pick): Added class MachineSchedInfo and several supporting classes
+d0513476dc87 HEAD@{561}: rebase (pick): Implementation of instruction scheduling for LLVM.
+3222a43515d4 HEAD@{562}: rebase (pick): Class that encapsulates priority heuristics for instruction scheduling.
+a3bb9d7ef0f4 HEAD@{563}: rebase (pick): Scheduling DAG for instruction scheduling. Currently for a single basic block.
+f4be165ab676 HEAD@{564}: rebase (pick): Moved debug options declaration to header file, and moved
+f914ba215bc2 HEAD@{565}: rebase (pick): Moved function PrintMachineInstructions here.
+fb1a19d9a411 HEAD@{566}: rebase (pick): analyze() now checks to see that we don't analyze the same method twice.
+9e8f74af6ec5 HEAD@{567}: rebase (pick): *** empty log message ***
+3a2656af412d HEAD@{568}: rebase (pick): Simplification transformations to normalize the code for later passes.
+bbb02c1d7c9b HEAD@{569}: rebase (pick): Use const int instead of #define.
+d0b683357562 HEAD@{570}: rebase (pick): Add copy and assignment operators for POIterator, and
+9f98fb5b9284 HEAD@{571}: rebase (pick): Added InstrSched library to link line.
+dac45308ccd6 HEAD@{572}: rebase (pick): I suck
+ff67dcc22be0 HEAD@{573}: rebase (pick): Initial checkin of TargetData code
+8472822ff914 HEAD@{574}: rebase (pick): Remove target specific stuff from Type classes
+13bd108c03e0 HEAD@{575}: rebase (pick): Remove target specific method from MemAccessInst class
+2771054dbf3e HEAD@{576}: rebase (pick): Convert to use the new factored out TargetData class
+ddadbddb187b HEAD@{577}: rebase (pick): Factor code out to the TargetData class
+3e08de6cee86 HEAD@{578}: rebase (pick): Use the new TargetData class to factor out some of the shared code
+729c3d47e91e HEAD@{579}: rebase (pick): Remove target specific method.
+5ca1a2bcbc44 HEAD@{580}: rebase (pick): Remove target specific code, move to TargetData.cpp file
+7cd798c969a4 HEAD@{581}: rebase (pick): Support passing a data pointer to annotation factory methods
+3b3efaeeaf76 HEAD@{582}: rebase (pick): Demolish explicit source list
+1afbb4027fae HEAD@{583}: rebase (pick): Extend annotations to pass data pointers around to the functions
+74782cb4a340 HEAD@{584}: rebase (pick): Add another TODO: sigh
+ab8c3000e11e HEAD@{585}: rebase (pick): Lots of new functionality
+a9a8941bb775 HEAD@{586}: rebase (pick): Remove explicit source list
+f011d42626b3 HEAD@{587}: rebase (pick): Add dependence to libvmcore.
+37c91bae4bcd HEAD@{588}: rebase (pick): Make sure noone branches to the entry node of the method
+ee0ddad61d01 HEAD@{589}: rebase (pick): Compile LLI
+d34454f43919 HEAD@{590}: rebase (pick): Rename start methods to main so interpreter works easier
+44dfadcd4a33 HEAD@{591}: rebase (pick): Add annotation support
+03d42fd345d1 HEAD@{592}: rebase (pick): Handle case where there is no exit node from a flowgraph
+6c329f4eaed8 HEAD@{593}: rebase (pick): Changed an assertion message
+350d117dbdd5 HEAD@{594}: rebase (pick): Add annotation support to value
+311767f056af HEAD@{595}: rebase (pick): * Add assertions
+55c6be031f13 HEAD@{596}: rebase (pick): Initial checkin of interpreter
+3fdb0df0b0b2 HEAD@{597}: rebase (pick): LV code on machine instructions
+19e88d249e25 HEAD@{598}: rebase (pick): LV info on machine instructions
+b1dfaf6145ab HEAD@{599}: rebase (pick): Corrected the compilation error by making the ValOperator class a friend of
+3059c0b24b7c HEAD@{600}: rebase (pick): Always set isDef for operand in position resultPos.
+081ab0fa9e0f HEAD@{601}: rebase (pick): Changed SetMachineOpernad calls in Set3OperandsFromInstr so that the
+6be8772e0463 HEAD@{602}: rebase (pick): Changed case 64 to make the first arg of phi a defintion
+abc698370478 HEAD@{603}: rebase (pick): Can't use ref to stack value!
+56e7b4262d3e HEAD@{604}: rebase (pick): Needed old conditions as well as new in skipToNextVal()!
+2b2d58164051 HEAD@{605}: rebase (pick): Bug fix in ValOpIterator: not moving past operand with NULL Value.
+4a1a05bc1473 HEAD@{606}: rebase (pick): *** empty log message ***
+32525540235d HEAD@{607}: rebase (pick): added a default isDef arg to SetMachineOperand method - Ruchira
+ac7c6045f846 HEAD@{608}: rebase (pick): Added isDef field to MachineOperand class - Ruchira
+f0942ac597e7 HEAD@{609}: rebase (pick): Add CC operand as 4th operand of SUBcc, and mark it as a def.
+9568ebd1a049 HEAD@{610}: rebase (pick): Use extra operand for instructions that set a CC register that
+17d5bdb8c5dc HEAD@{611}: rebase (pick): Also, move burg rule to Makefile.common.
+5efe6ec39c6f HEAD@{612}: rebase (pick): And add rule to create a .cpp source file from burg input file!
+5b8a3ae17209 HEAD@{613}: rebase (pick): Better still, lets move pathname for Burg to Makefile.common.
+415c589a5b97 HEAD@{614}: rebase (pick): Add path and options for burg.
+15a90d21c83f HEAD@{615}: rebase (pick): Use full pathname for burg.
+044f893ad519 HEAD@{616}: rebase (pick): Allow numOperands of -1 for variable #operands.
+6b7eebde250d HEAD@{617}: rebase (pick): Simplify command line options, and add option for printing
+5ac12a3af462 HEAD@{618}: rebase (pick): Had used the wrong option.
+27df4e0f0c54 HEAD@{619}: rebase (pick): Added tree nodes for Phi instructions.
+3d470f658f50 HEAD@{620}: rebase (pick): Generate tree nodes for Phi instructions.
+5745231c1ee0 HEAD@{621}: rebase (pick): Allow machine instructions with variable numbers of arguments.
+3de046767b96 HEAD@{622}: rebase (pick): Added dummy Phi instruction.
+7df9d89320cb HEAD@{623}: rebase (pick): Generate dummy Phi machine instruction, plus a bug fix for BrCond(boolreg).
+371350759bd5 HEAD@{624}: rebase (pick): Added support for testing instruction selection on all but 2 tests.
+09c28c22fde1 HEAD@{625}: rebase (pick): Added class MachineCodeForBasicBlock.
+ee4ef4ffe10c HEAD@{626}: rebase (pick): Record machine instructions in the vector for each basic block.
+75e6a0432e3b HEAD@{627}: rebase (pick): Added vector of machine instructions for the basic block.
+6c523d7b3a45 HEAD@{628}: rebase (pick): New test cases
+a991e5fcc19d HEAD@{629}: rebase (pick): Remove some gross stuff
+33162a8d8802 HEAD@{630}: rebase (pick): Allow vararg method types with 0 fixed types
+18a61fcb43a4 HEAD@{631}: rebase (pick): Make error msg nicer
+c3e2fe5af54b HEAD@{632}: rebase (pick): Enable the elimination of method prototypes that are not referenced
+8fb736efbcdd HEAD@{633}: rebase (pick): * Make sure that the size of the type field can also control the output
+a9dab08596d3 HEAD@{634}: rebase (pick): * Add calls to failure template so that it is actually possible to debug
+077a425d4516 HEAD@{635}: rebase (pick): * Fix bugs
+03c4f8933762 HEAD@{636}: rebase (pick): * Enable the use of escaped literal strings
+934c4b501a22 HEAD@{637}: rebase (pick): Modify var names to make it apparant that the code is really generic
+0a587153f15f HEAD@{638}: rebase (pick): Changes to make test scripts more reliable
+e67cf2e7e23d HEAD@{639}: rebase (pick): Add test of string constants
+c20b0ebc51c4 HEAD@{640}: rebase (pick): Added function printIndent.
+841fdaf6e2f7 HEAD@{641}: rebase (pick): Added a pointer hash function object for use in pointer maps.
+65fb5153e342 HEAD@{642}: rebase (pick): Make a function const.
+0762b37e7677 HEAD@{643}: rebase (pick): Remove lib/LLC library.
+cf6a5702c91e HEAD@{644}: rebase (pick): Added several SPARC instructions including conditional move and SETHI.
+1fc9217c15ee HEAD@{645}: rebase (pick): Remove redundant and unused functions.
+76b1285bfdc7 HEAD@{646}: rebase (pick): Added UltraSparcInstrInfo class to specialize class MachineInstrInfo.
+6e560c22a4f9 HEAD@{647}: rebase (pick): Eliminate unused function.
+5384b204a5da HEAD@{648}: rebase (pick): Bug fixes:
+898348afb52d HEAD@{649}: rebase (pick): Added MachineInstrInfo class and moved instruction-related members there.
+0c2462a079ed HEAD@{650}: rebase (pick): Eliminate separate enum for operand register type.
+eac34ac45c71 HEAD@{651}: rebase (pick): Work around a few 'sorting issues' with the bytecode output that causes the bytecode
+94e2da805ed4 HEAD@{652}: rebase (pick): Don't write out constants that do not have a name, they will be inlined.
+0fb64b07f943 HEAD@{653}: rebase (pick): Refactor some of the constant stuff so that we can return complex constant
+ad7945a175d6 HEAD@{654}: rebase (pick): Add an arg to insertVal to allow us to prevent builtin types from being ignored
+fe70c81141d7 HEAD@{655}: rebase (pick): Add an arg to insertVal to allow us to prevent builtin types from being ignored
+f2a10b61e2a7 HEAD@{656}: rebase (pick): New test for varargs functions
+d7f49ed443ab HEAD@{657}: rebase (pick): Add library dep
+fd413193db44 HEAD@{658}: rebase (pick): Parenthesize output for expranalyze so that pointer stuff being multiplied isn't confusing
+88bb8ebe01fd HEAD@{659}: rebase (pick): Build as before dis
+392cb8a9804a HEAD@{660}: rebase (pick): Add support for extern varargs methods & varargs method calls
+89cb2de0eeac HEAD@{661}: rebase (pick): Add support for extern varargs methods & varargs method calls
+aad7190b6bea HEAD@{662}: rebase (pick): Fix a bug when compiling 'shl ubyte * %var, ubyte 2'
+b5d668969e65 HEAD@{663}: rebase (pick): Filter out noncore stuff
+36123a777b5e HEAD@{664}: rebase (pick): Fixed a bug exposed when doing something like this: <program> -notanoption --help
+a9622c681ad6 HEAD@{665}: rebase (pick): Changed printValue() to print constant value if the value is a constant.
+bb2db6c88f8a HEAD@{666}: rebase (pick): *** empty log message ***
+8d83c40582cc HEAD@{667}: rebase (pick): Doh! Wrong Optional flag. :(
+a6c90bf6ee4c HEAD@{668}: rebase (pick): Add a comment indicating that there is documentation of the library
+a98afe4b0579 HEAD@{669}: rebase (pick): Initial checking of some rough documentation for commandline library
+48fca76a95a8 HEAD@{670}: rebase (pick): Change option name slightly
+f62a2f2be6a9 HEAD@{671}: rebase (pick): Minor changes to implementation of CommandLine library to let users override
+6c74f799d80b HEAD@{672}: rebase (pick): Add a missing </a> tag
+026bec7cf715 HEAD@{673}: rebase (pick): Use the new Alias command line option
+d2ec898cfb0e HEAD@{674}: rebase (pick): CommandLine library cleanup. No longer use getValue/setValue, instead, just treat the commandline
+f74319d29b56 HEAD@{675}: rebase (pick): Doh! Wrong accessor. Caused 'can not read bytecode' errors. :(
+104c6f0c01f6 HEAD@{676}: rebase (pick): -help is verbose enough that we don't need this anymore
+b0dcda34759b HEAD@{677}: rebase (pick): Eliminated the Unique class in favor of NonCopyable and NonCopyableV
+ec8abea1c777 HEAD@{678}: rebase (pick): Moved inline/llvm/Tools/* to include/llvm/Support/*
+f434f8970fdd HEAD@{679}: rebase (pick): Initial checkin
+bd177131a770 HEAD@{680}: rebase (pick): Fix coding style issues to actually attempt to be somewhat uniform
+f4c632fabc9b HEAD@{681}: rebase (pick): Nonpolymorphic class, doesn't need a virtual dtor!
+7bc807e14176 HEAD@{682}: rebase (pick): Clean up hash table usage
+efe8c7aa1cf0 HEAD@{683}: rebase (pick): Removal of the redundant CompileContext wrapper
+b099c14cc8ba HEAD@{684}: rebase (pick): Verbosify descriptions
+b72d002be10f HEAD@{685}: rebase (pick): Large scale changes to implement new command line argument facility
+23381cd5b5a1 HEAD@{686}: rebase (pick): Remove dependence on command line library. Silly anyway.
+4ee192c0ff7a HEAD@{687}: rebase (pick): Make it pickier
+442f68038647 HEAD@{688}: rebase (pick): Add flag for emacs so it realizes it's C++ code
+99c4af7c6b12 HEAD@{689}: rebase (pick): New test case
+01ef66c762bb HEAD@{690}: rebase (pick): Privatize LLCOptions. It had no business being visible to the entire
+b18d26deb43d HEAD@{691}: rebase (pick): Move private header into private directory
+57cb798a4677 HEAD@{692}: rebase (pick): Convert from using C style char*'s to strings.
+144db6c30c7a HEAD@{693}: rebase (pick): Remove String file some more
+78fc43ff73cb HEAD@{694}: rebase (pick): Remove stringutils.h file
+3b9829cf7645 HEAD@{695}: rebase (pick): Destroy the StringUtils.h file
+a1f7c42bcb01 HEAD@{696}: rebase (pick): Eliminate lots of unnecessary #includes and forward decls
+f5e75c7e705d HEAD@{697}: rebase (pick): Eliminate many unneccesary #includes
+1aa17f3bb25c HEAD@{698}: rebase (pick): Make code fit in 80 columns more
+b95c07e35c7f HEAD@{699}: rebase (pick): Remove unneccesary #includes
+5381f682dd30 HEAD@{700}: rebase (pick): Exterminate nasty Cisms
+11f554634433 HEAD@{701}: rebase (pick): Refer to include/llvm/CodeGen not Codegen
+d2e18d70c558 HEAD@{702}: rebase (pick): Instructions for use
+34e368c59b5b HEAD@{703}: rebase (pick): Make sure we build all of the code!
+f0d858ed34f1 HEAD@{704}: rebase (pick): Renamed include/llvm/Codegen to include/llvm/CodeGen
+6c8ccac2de98 HEAD@{705}: rebase (pick): Fix code to be in a consistent style
+c267a7d71c7b HEAD@{706}: rebase (pick): More minor reorganizations
+51777d7f1b52 HEAD@{707}: rebase (pick): Remove getTempValuesForMachineCode from the Instruction interface
+21be61506817 HEAD@{708}: rebase (pick): Filter out the sparc.burm.c file
+ef91903bfcbf HEAD@{709}: rebase (pick): Moved LLC subdir to the tools top level directory
+0e90eb4b6eb7 HEAD@{710}: rebase (pick): Make the makefile work
+345e38ed07ac HEAD@{711}: rebase (pick): Add new ctor for ConstPoolBool
+9d9614205cf1 HEAD@{712}: rebase (pick): Add new constructor for const pool bool
+363bdd9a0676 HEAD@{713}: rebase (pick): Add support for casts
+7fd6dcb064ef HEAD@{714}: rebase (pick): Add support for casting operators
+61f218f640e2 HEAD@{715}: rebase (pick): Support changed expression api
+0d64b2ba0a9c HEAD@{716}: rebase (pick): More functionality, renamed API
+df5dbc8e3949 HEAD@{717}: rebase (pick): Moved isIntegral to the Type system
+a61ce81cc4d8 HEAD@{718}: rebase (pick): Autodep functionality broken. Remove so we get successful builds
+148b96074cee HEAD@{719}: rebase (pick): Version of testmemory to test alloca, load and store.
+5153d313b0ce HEAD@{720}: rebase (pick): Used a bigger constant in loopfunc.ll that doesn't fit in immed field.
+36eb43e26456 HEAD@{721}: rebase (pick): Utility routines for simpler access to the value of an integer constant.
+e31cf51c03a4 HEAD@{722}: rebase (pick): Program options class.
+2339d0cf578d HEAD@{723}: rebase (pick): Driver and options for the llc compiler.
+03cdc0b1bceb HEAD@{724}: rebase (pick): Description of the SPARC as a target architecture.
+dd4b4355c99d HEAD@{725}: rebase (pick): Base clas for a description of a target architecture.
+8a2e2fbd50e6 HEAD@{726}: rebase (pick): Instruction selection via pattern matching on instruction trees using BURG.
+fea7ff57c801 HEAD@{727}: rebase (pick): *** empty log message ***
+fae069f4e36b HEAD@{728}: rebase (pick): Added CodeGen, LLC, and Support.
+24812650a87f HEAD@{729}: rebase (pick): General support utilities like a program options class and a StringMap
+7c52e8197cf9 HEAD@{730}: rebase (pick): CompileContext and options class for the llc compiler.
+aed61d90db66 HEAD@{731}: rebase (pick): Header files for the target architecture description and for instruction
+82015f75875f HEAD@{732}: rebase (pick): Added support for getting the dependence of an executable on its libs,
+70d2dc737e0b HEAD@{733}: rebase (pick): Add isIntegral() method to SignedIntType and UnsignedIntType.
+c7371d8afb38 HEAD@{734}: rebase (pick): Provide simpler ways to extract the value of an integer constant.
+15e79bcb6e4b HEAD@{735}: rebase (pick): Compute and cache information about the storage size and layout
+6b94be0fa4af HEAD@{736}: rebase (pick): Provide uniform access to the pointer operand and to the index
+2010845c92f1 HEAD@{737}: rebase (pick): Added a representation of the machine instructions generated
+213160e0bb9f HEAD@{738}: rebase (pick): Start of expression analysis support
+9250c349b550 HEAD@{739}: rebase (pick): Header to raise and lower representation
+56dbc9359f2b HEAD@{740}: rebase (pick): Add support to call LevelRaise
+6ffd08afd81c HEAD@{741}: rebase (pick): Update makefile for more accurate deps
+f2df47febf1b HEAD@{742}: rebase (pick): Implement ensureTypeAvailable
+e06171c5109f HEAD@{743}: rebase (pick): Add support for constant propogation of multiplies
+ec9be9e818a5 HEAD@{744}: rebase (pick): Factor out WriteAsOperand.
+4bef44e0adfc HEAD@{745}: rebase (pick): Add a comment.
+f012589e78ed HEAD@{746}: rebase (pick): Add multiply as a supported constant propogation operation
+643641cb450c HEAD@{747}: rebase (pick): New function: WriteAsOperand.
+80470d72e903 HEAD@{748}: rebase (pick): Add new base class ConstPoolInt, useful for dealing with integral constants
+7a5ca318dfe7 HEAD@{749}: rebase (pick): Add new method, ensureTypeAvailable
+9abf2d95c339 HEAD@{750}: rebase (pick): Change is*Type to be a casting convertion operator
+a7a79aafa026 HEAD@{751}: rebase (pick): Add an function to BinaryOperator to swap the two operands
+f8bb46fb137c HEAD@{752}: rebase (pick): Add short forms of the get*Type methods.
+9dbc6bb6b44d HEAD@{753}: rebase (pick): Fix nasty typo
+d59d2aa4a97e HEAD@{754}: rebase (pick): Fix clean target
+bf1c55b14525 HEAD@{755}: rebase (pick): Compile source files in alphabetical order
+02990b116ef2 HEAD@{756}: rebase (pick): Fixed typo in comment
+f5b88528d736 HEAD@{757}: rebase (pick): Support external methods
+643d6d93c309 HEAD@{758}: rebase (pick): New test case for prototype support
+12bb537e90da HEAD@{759}: rebase (pick): Reordered link line for correct static linking.
+903f9efa3f84 HEAD@{760}: rebase (pick): Changed default to building library archives instead of shared objects.
+aabc8315f101 HEAD@{761}: rebase (pick): Implement forward/external declarations for methods.
+64e2c4726aa8 HEAD@{762}: rebase (pick): Implement forward/external declarations for methods. Also, emit an error if a method
+a2be53991d96 HEAD@{763}: rebase (pick): Rename 'isMethodExternal' to 'isExternal'
+af58b501dadf HEAD@{764}: rebase (pick): Add notes on instruction selection pass
+3be6a7da5434 HEAD@{765}: rebase (pick): New testcase from GCC doing array operations
+5702913064a2 HEAD@{766}: rebase (pick): Add support for assembly printing fp constants
+05c8093e0529 HEAD@{767}: rebase (pick): Add support to the bytecode writer to recognize floating point constants
+55f91192bf7c HEAD@{768}: rebase (pick): Add support to the bytecode reader to recognize floating point constants
+828ae092b096 HEAD@{769}: rebase (pick): Add support to the parser to recognize floating point constants
+9d78fb9b25fa HEAD@{770}: rebase (pick): Add a function to convert a double to a string
+d25973d16cd9 HEAD@{771}: rebase (pick): Add support to write and read a fixed amount of raw data
+c35d12757fd4 HEAD@{772}: rebase (pick): Add a note
+94c6d03b6c82 HEAD@{773}: rebase (pick): * ValueHolder now takes 3 arguments
+67b11a5bd739 HEAD@{774}: rebase (pick): Add knowledge about the struct form of the GetElementPtr instruction
+06adb0b2ab08 HEAD@{775}: rebase (pick): Remove dependency on the structure of ValueHolder.
+0559fb6b55e4 HEAD@{776}: rebase (pick): * The parent of a constant pool is a symtabvalue, not a value.
+fb6d8d18898e HEAD@{777}: rebase (pick): The parent of a constant pool is a symtabvalue, not a value.
+c20531f12219 HEAD@{778}: rebase (pick): Added some comments, preparing to add global variables and method prototypes
+39fae71357a5 HEAD@{779}: rebase (pick): * The parent of a constant pool is a SymTabValue, not a value.
+e3812fad3a2d HEAD@{780}: rebase (pick): Made the following changes:
+c6df40cee22e HEAD@{781}: rebase (pick): Added more todo's. Don't I ever accomplish anything?
+6ee823f32e3d HEAD@{782}: rebase (pick): Add DebugValue member.
+c8281fb7bdfe HEAD@{783}: rebase (pick): Made it not inline
+e0c85017da0a HEAD@{784}: rebase (pick): Add DebugValue global function
+a93311112bbc HEAD@{785}: rebase (pick): Don't clean out the type plane of the constant pool... this is a hack. FIXME
+97add160370e HEAD@{786}: rebase (pick): Make sure that types go in the constant pool if they are used.
+3f0bab207223 HEAD@{787}: rebase (pick): hasSideEffects should be marked virtual
+08fc7cf1be14 HEAD@{788}: rebase (pick): Modify notes
+96f249a20298 HEAD@{789}: rebase (pick): Fix stupid typo
+c874f2e554d5 HEAD@{790}: rebase (pick): Initial checkin of coding standards
+c0abd659a4e3 HEAD@{791}: rebase (pick): Updated documentation for load, store & getelementptr
+8ff1023c5729 HEAD@{792}: rebase (pick): add coverage of newly implemented instructions.
+87ad59d49e91 HEAD@{793}: rebase (pick): Implementation of Store & GetElementPtr
+2b2b55bdec44 HEAD@{794}: rebase (pick): Implement checking for new instructions
+4fb6aa4a9e7a HEAD@{795}: rebase (pick): Add note
+e9d048cd6792 HEAD@{796}: rebase (pick): Implemented shl, shl, & load instructions
+5833b72ec4b1 HEAD@{797}: rebase (pick): Moved Cast from being a Unary instruction to being an "Other" instruction
+6b062514ff40 HEAD@{798}: rebase (pick): Use the CDG to mark branches alive on demand.
+3005d00fa8dd HEAD@{799}: rebase (pick): Add a new "addOperand" method to User.
+4cb53fdaeffb HEAD@{800}: rebase (pick): Fixed post dominator frontiers! Yaay!
+aa86a73a5bec HEAD@{801}: rebase (pick): Neg instruction removed. Cast instruction implemented.
+842d6e099476 HEAD@{802}: rebase (pick): Neg instruction removed. TODO item fulfilled.
+7550203543d2 HEAD@{803}: rebase (pick): Removing unnecesary file
+6c99b25c3bd8 HEAD@{804}: rebase (pick): Convert BinaryOperand and UnaryOperator to only take instruction types of
+eea771ae35ce HEAD@{805}: rebase (pick): Broad superficial changes:
+8b0f42aa64c1 HEAD@{806}: rebase (pick): Devirtualize User::dropAllReferences
+b6af5d386268 HEAD@{807}: rebase (pick): Remove dtor's that simply call dropAllReferences
+70707b9adf64 HEAD@{808}: rebase (pick): Changed the fundemental architecture of Operands for Instructions. Now
+bc4bfa70b8e0 HEAD@{809}: rebase (pick): Changed memory reference instructions to store the result as the implicit
+dd91a3d2d9e7 HEAD@{810}: rebase (pick): Fixed some error messages to be nicer
+7f723d15a495 HEAD@{811}: rebase (pick): Add note about nuking Instruction::neg
+a75385aa3c2e HEAD@{812}: rebase (pick): Initial checkin
+93634e0499a7 HEAD@{813}: rebase (pick): Add better support for post dominator information.
+0528ba902343 HEAD@{814}: rebase (pick): Add method to unify all exit nodes of a method
+947db1d96a4f HEAD@{815}: rebase (pick): Implement support for postdominators, except in dom frontiers
+a534bd635e5e HEAD@{816}: rebase (pick): New file, includes method to merge exit nodes together
+9996c4da5186 HEAD@{817}: rebase (pick): * Add a DominatorBase base class to maintain root of Dominator info
+042a9c01050d HEAD@{818}: rebase (pick): * Added comments
+b30075f1d1b2 HEAD@{819}: rebase (pick): Update to include right file
+b655a756d6a9 HEAD@{820}: rebase (pick): Initial checkin of analyze tool.
+2c1174ab6df2 HEAD@{821}: rebase (pick): Build new analyze tool
+8350bbd20ae5 HEAD@{822}: rebase (pick): Added analyze to path for SetupOpt script
+c705cdc36c17 HEAD@{823}: rebase (pick): Add analyze tool to path for Setup script
+b18d4fae85b6 HEAD@{824}: rebase (pick): IntervalPartition was changed to inherit from vector<Interval*> instead of
+743ecc7f0095 HEAD@{825}: rebase (pick): IntervalPartition was changed to inherit from vector<Interval*> instead of
+f95290eba1c4 HEAD@{826}: rebase (pick): *** empty log message ***
+39b38db21649 HEAD@{827}: rebase (pick): Checkin of new Analysis result printing header
+c16998cb96e5 HEAD@{828}: rebase (pick): Code got moved from the lib/Assembly/Writer/IntervalWriter.cpp file to
+49090bf698f5 HEAD@{829}: rebase (pick): Remove code for printing out Analysis data structures. It got moved
+2149e63cb883 HEAD@{830}: rebase (pick): Update documentation a bit, correct #include guard
+b048f8d4a4b3 HEAD@{831}: rebase (pick): Add note about tool idea. Change command line of note to be more specific
+62e192f9ef8f HEAD@{832}: rebase (pick): Add printing code for dominator info
+5630a5fac34d HEAD@{833}: rebase (pick): Checkin of new dominator calculation routines. These will be improved in
+ee98cbc6c810 HEAD@{834}: rebase (pick): Enable printing of dominator related information.
+889fa47ccf94 HEAD@{835}: rebase (pick): Add new anaysis routines for building dominator related information
+98e49f4ca414 HEAD@{836}: rebase (pick): Addition of 'deleter' function.
+bac6bb0ae065 HEAD@{837}: rebase (pick): Moved deleter to include/llvm/Tools/STLExtras.h
+de19f162cc14 HEAD@{838}: rebase (pick): Initial checkin. Should print dead instructions, except it doesn't do
+4fb09389a03b HEAD@{839}: rebase (pick): Include ADCE pass, rename include/Opt directory to llvm/Optimizations
+d56c334ebb78 HEAD@{840}: rebase (pick): Rename DoSparseConditionalConstantProp -> DoSCCP
+d8c1f57237a1 HEAD@{841}: rebase (pick): Add note
+c355930e34c8 HEAD@{842}: rebase (pick): Add prototypes for ADCE pass
+a9aaeed69342 HEAD@{843}: rebase (pick): Rename DoSparseConditionalConstantProp to DoSCCP
+82abf7e9b6fa HEAD@{844}: rebase (pick): Optimizations got their own header files
+c49280c35c8a HEAD@{845}: rebase (pick): Implement reduceApply method
+512b32b42708 HEAD@{846}: rebase (pick): Add a new pop_back() method
+c2d246ce3e77 HEAD@{847}: rebase (pick): The ConstRules class got moved to the opt namespace
+6167d0001fe5 HEAD@{848}: rebase (pick): Add a reduceApply method
+d78e27809d32 HEAD@{849}: rebase (pick): Split AllOpts.h into lots of little .h files.
+0963fce4a854 HEAD@{850}: rebase (pick): Export ConstantFoldTerminator, allow it to fold conditional branches to
+849231387470 HEAD@{851}: rebase (pick): Added documentation. Constant fold terminators.
+6ff2d0ae85ce HEAD@{852}: rebase (pick): Added prototype for ConstantFoldTerminator
+6fe27ce22949 HEAD@{853}: rebase (pick): Add a check to avoid allowing V->replaceAllUsesWith(V)
+3f6c78a176e1 HEAD@{854}: rebase (pick): Add implementation of BasicBlock::removePredecessor code that was factored
+ba8f2c1f6a6f HEAD@{855}: rebase (pick): * Factored RemovePredecessorFromBlock into BasicBlock::removePredecessor
+b0e4bdf5d6d0 HEAD@{856}: rebase (pick): We need to make sure to remove PHI nodes in the successor that cannot be
+ca8d6d3dd907 HEAD@{857}: rebase (pick): Added a note about a new verification the verifier should do
+0686d990fbf0 HEAD@{858}: rebase (pick): Added new removePredecessor method prototype
+8930ec2756c1 HEAD@{859}: rebase (pick): Added note, moved note
+6109478c092c HEAD@{860}: rebase (pick): Fixed the obnoxious problem that caused an entire directory to rebuild
+f2eab63950b5 HEAD@{861}: rebase (pick): Miscellaneous cleanups:
+63286b72d223 HEAD@{862}: rebase (pick): Add a new Sparse Conditional Constant Propogation pass
+324c5dcc9d82 HEAD@{863}: rebase (pick): Add command line arguments for Constant Pool Merging & Sparse Conditional Constant Prop
+b412bc074f36 HEAD@{864}: rebase (pick): Put in test of SCCP. Watch out though, because we need to sort the
+b4bb71fd0f0d HEAD@{865}: rebase (pick): Change to use the new GenericBinaryInst class. Support lots more operators.
+b00b3f2b682d HEAD@{866}: rebase (pick): Misc cleanup
+540c4ae24c8e HEAD@{867}: rebase (pick): * Expose DoConstantPoolMerging
+955a4d740cb4 HEAD@{868}: rebase (pick): Convert ugly postincrement to efficient preincrement
+1dacaa7057bf HEAD@{869}: rebase (pick): * Move stuff around a bit.
+926791f1ca54 HEAD@{870}: rebase (pick): Add instructions to fold unary and binary instructions.
+77090a9ae8e4 HEAD@{871}: rebase (pick): * Use the new reduce_apply_bool template
+d564849afb96 HEAD@{872}: rebase (pick): getBasicBlocks() is not needed anymore for reading Method data
+c9c6da3ca1f7 HEAD@{873}: rebase (pick): Added methods to make dealing with switches and branch instructions
+5b8794782e8c HEAD@{874}: rebase (pick): Minor formating changes
+259afbe701de HEAD@{875}: rebase (pick): Make a new GenericBinaryInst class, instead of providing lots of silly
+f26fbe244a3c HEAD@{876}: rebase (pick): Convert postincrements to more efficient preincrements
+a685acebd652 HEAD@{877}: rebase (pick): Add a new slew of functions to allow dynamic_cast<> like operation for
+49e5848f7266 HEAD@{878}: rebase (pick): Add extra forwarding accessor methods so that getMethodList(), getBasicBlocks()
+41a60e4b2e4f HEAD@{879}: rebase (pick): Add more notes
+0f81680a2104 HEAD@{880}: rebase (pick): Filter out some more stuff
+0bf0d89d693b HEAD@{881}: rebase (pick): Moved UnaryOperator::create to InstrTypes.cpp until there is an iUnaryOps.cpp
+4d5a89c84cd7 HEAD@{882}: rebase (pick): Implement induction variable injection!
+c463b997b86a HEAD@{883}: rebase (pick): Renamed get.*Operator to create seeing that it would have to be qualified
+ef4669a3e67b HEAD@{884}: rebase (pick): * Rename get.*Operator to create seeing that it would have to be qualified
+e51131d287ae HEAD@{885}: rebase (pick): A silly stupid test of the loop depth calculator was added. REMOVE in the
+d06ca69a78ce HEAD@{886}: rebase (pick): IntervalPartition: recode to use IntervalIterator to do all the work
+d2fd00e218cb HEAD@{887}: rebase (pick): Add a helper function bind_obj
+7fc109749907 HEAD@{888}: rebase (pick): Big changes. Interval*.h is now more or less finalized. IntervalPartition
+5848055f471b HEAD@{889}: rebase (pick): CFG.h: change the iterator tag
+c1eafb1d07ab HEAD@{890}: rebase (pick): ValueHolder's aren't interseting to me anymore
+b1abed97808e HEAD@{891}: rebase (pick): New file due to the Intervals.h splitup
+0724b3e90091 HEAD@{892}: rebase (pick): New files due to the Intervals.h splitup
+ba91baa363b7 HEAD@{893}: rebase (pick): Add a useless phi for testing with InductionVariables stuff
+f916541417e3 HEAD@{894}: rebase (pick): #include a 
diff erent header due to Intervals.h splitting up
+5329f8f73c86 HEAD@{895}: rebase (pick): IntervalPartition & IntervalIterator classes have been split out into
+fbea208252f0 HEAD@{896}: rebase (pick): IntervalPartition & IntervalIterator classes have been split out into
+d828c7706db9 HEAD@{897}: rebase (pick): Prepare for split between Interval, IntervalIterator, and IntervalIPartition
+3b3d00dffb19 HEAD@{898}: rebase (pick): Addition of IntervalIterator. Preparing for rename of Intervals.h to
+f948fd9866ee HEAD@{899}: rebase (pick): Added notes
+d41887123b2e HEAD@{900}: rebase (pick): Implement a lot more functionality. Now loop invariant and linear
+d9b7e634b62b HEAD@{901}: rebase (pick): Interval::HeaderNode is now accessed thorugh an accessor function
+32f9e9270229 HEAD@{902}: rebase (pick): Add comments
+a3eb9281f099 HEAD@{903}: rebase (pick): Add accessor methods to binary/unary operators
+b03e9bf9c388 HEAD@{904}: rebase (pick): Add a space to the PHI node output code to make it look nicer
+605e752f0429 HEAD@{905}: rebase (pick): Moved printing code to the Assembly/Writer library.
+8d6f5b857ebb HEAD@{906}: rebase (pick): Implement the new Interval::isLoop method
+bc792603f8b8 HEAD@{907}: rebase (pick): New header file defined with neeto utilities put in one place
+3b59035da7ea HEAD@{908}: rebase (pick): Modified to use the new reduce_apply algorithm
+58967efc5647 HEAD@{909}: rebase (pick): * Added capability to print out an interval
+0246e25d77a6 HEAD@{910}: rebase (pick): * Added comments
+f88d93ea7fac HEAD@{911}: rebase (pick): Add a test case: an irreducible flow graph.
+d9d7c6d1179e HEAD@{912}: rebase (pick): Get rid of a silly printout that isn't needed right now
+667d489ab2c9 HEAD@{913}: rebase (pick): Add note
+7d9fb3ab2fe8 HEAD@{914}: rebase (pick): New test case
+6cdff3cad3c3 HEAD@{915}: rebase (pick): Add capability to print a derived interval graph
+7ac17927b805 HEAD@{916}: rebase (pick): Add capability to build a derived interval graph
+56e38307935f HEAD@{917}: rebase (pick): Factor the predeclarations of the CFG.h functionality into a seperate, new header
+ea614fef124f HEAD@{918}: rebase (pick): Initial Checking of Interval handling code
+644acdbfe034 HEAD@{919}: rebase (pick): Add stub for induction variable code
+0a9fdd55c1ca HEAD@{920}: rebase (pick): Add a more complex test case
+92e26fb33e21 HEAD@{921}: rebase (pick): Add a test case for interval code
+5a4847e078a6 HEAD@{922}: rebase (pick): Add an optimization stub
+423d0a2d3762 HEAD@{923}: rebase (pick): New file: Interval analysis support
+f0e51696b0f1 HEAD@{924}: rebase (pick): Add a note
+7b1bb4951dbd HEAD@{925}: rebase (pick): Filter out more stuff I don't want all the time
+df4258024997 HEAD@{926}: rebase (pick): Removed silly test code
+118b768314e8 HEAD@{927}: rebase (pick): Added options to print out basic blocks in a variety of 
diff erent orderings
+a925ae543736 HEAD@{928}: rebase (pick): Updates to work with new cfg namespace
+0b9af59e24ef HEAD@{929}: rebase (pick): Implement support for writing VCG format output
+388ad96269af HEAD@{930}: rebase (pick): Move contents to the cfg namespace.
+91078f85b47e HEAD@{931}: rebase (pick): Updates to support
+fba16076cade HEAD@{932}: rebase (pick): Updates to support
+fc5655471d3e HEAD@{933}: rebase (pick): Updates to support
+0a9d874b1031 HEAD@{934}: rebase (pick): Updates to support
+bcb3231d6613 HEAD@{935}: rebase (pick): Update documentation to reflect:
+db7f6e6d79ea HEAD@{936}: rebase (pick): Moved getBinaryOperator to the BinaryOperator class and the getUnaryOperator
+2cf6ee5926fe HEAD@{937}: rebase (pick): I actually got something done
+783091c4f5c6 HEAD@{938}: rebase (pick): Beautify the source a bit.
+94ea386b0c0c HEAD@{939}: rebase (pick): Include support for reverse iteration.
+059def0ab975 HEAD@{940}: rebase (pick): Added a stupid testcase for iterators.
+be3f7a5b9a7a HEAD@{941}: rebase (pick): Added reverse depth first capability, fixed depth first capability
+5b0379941c62 HEAD@{942}: rebase (pick): Updated to work with new CFG.h file.
+015520037831 HEAD@{943}: rebase (pick): Moved iterators to the new CFG.h file.
+b77ecaef3f49 HEAD@{944}: rebase (pick): New file
+2208b443367c HEAD@{945}: rebase (pick): inlining can change methods a second time, so don't rerun inliner when testing for
+d7ec7d53b0c1 HEAD@{946}: rebase (pick): Add extra method to PHI node class
+94a07501c89d HEAD@{947}: rebase (pick): Significant rework. DCE is still not done (see #ifdef'd out parts)
+110f15739545 HEAD@{948}: rebase (pick): Fixed to print slightly 
diff erently. Added use counts for labels
+add1ace044cd HEAD@{949}: rebase (pick): Fixes for BB iterators, additional methods added for DCE pass
+8a8e91d33707 HEAD@{950}: rebase (pick): Extra comments
+3bdcc96804e9 HEAD@{951}: rebase (pick): Now does not include instruction files...
+c6325331663d HEAD@{952}: rebase (pick): Initial revision
+f3f54944c027 HEAD@{953}: rebase (pick): New repository initialized by cvs2svn.
+8b754e2f7567 (origin/master, fork/master) HEAD@{954}: rebase (start): checkout origin/master
+1dc8f4774d34 HEAD@{955}: checkout: moving from main to arraytype
+72ea6fbc150a HEAD@{956}: checkout: moving from recoverreturn to main
+549498c110fa (recoverreturn) HEAD@{957}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+500ba6619cf3 HEAD@{958}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+256e9d00f6a8 HEAD@{959}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+056fc2e74960 HEAD@{960}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+d537c309a9d4 HEAD@{961}: commit: [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+72ea6fbc150a HEAD@{962}: checkout: moving from main to recoverreturn
+72ea6fbc150a HEAD@{963}: rebase (finish): returning to refs/heads/main
+72ea6fbc150a HEAD@{964}: rebase (start): checkout origin/main
+9dc4af327b12 HEAD@{965}: checkout: moving from two to main
+8062dae7812f (two) HEAD@{966}: commit (amend): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+c5ce4cbfc3cd HEAD@{967}: rebase (finish): returning to refs/heads/two
+c5ce4cbfc3cd HEAD@{968}: rebase (pick): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+72ea6fbc150a HEAD@{969}: rebase (start): checkout origin/main
+c56122daac76 HEAD@{970}: checkout: moving from iwyustdlib to two
+f038610fb5f3 HEAD@{971}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+e7f383b77f38 HEAD@{972}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+23650256334a HEAD@{973}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+eb1c9e6fabaa HEAD@{974}: rebase (continue) (finish): returning to refs/heads/iwyustdlib
+eb1c9e6fabaa HEAD@{975}: rebase (continue): [clangd] Basic IncludeCleaner support for c/c++ standard library
+128c6ed73b8f HEAD@{976}: rebase (start): checkout origin/main
+2f3a9575f9ad HEAD@{977}: checkout: moving from stdlib to iwyustdlib
+cdfb640fe9e8 (stdlib) HEAD@{978}: checkout: moving from prettify to stdlib
+77cc7d2fd845 (prettify) HEAD@{979}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+97d9713c55bc HEAD@{980}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+0e1e531ca3ab HEAD@{981}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+2dcf689f661e HEAD@{982}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+22e53b9a3b3f HEAD@{983}: commit: [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+9dc4af327b12 HEAD@{984}: checkout: moving from main to prettify
+9dc4af327b12 HEAD@{985}: reset: moving to HEAD
+9dc4af327b12 HEAD@{986}: reset: moving to HEAD
+9dc4af327b12 HEAD@{987}: checkout: moving from 9dc4af327b12dfbcf90fde1641cd649c6814bf98 to main
+9dc4af327b12 HEAD@{988}: checkout: moving from main to origin/main
+2c644e2f71a5 HEAD@{989}: commit: FFix feature name in 9dc4af327b12dfbcf90fde1641cd649c6814bf98
+9dc4af327b12 HEAD@{990}: rebase (finish): returning to refs/heads/main
+9dc4af327b12 HEAD@{991}: rebase (pick): Re-land "[clang] Add early exit when checking for const init of arrays."
+4fedd4be385e HEAD@{992}: rebase (start): checkout origin/main
+a3fd292fed18 HEAD@{993}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+70b8662a502c HEAD@{994}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+2ff827ad7f2d HEAD@{995}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+9ad5cbdb06d8 HEAD@{996}: revert: Re-land "[clang] Add early exit when checking for const init of arrays."
+6f1a501fddae HEAD@{997}: checkout: moving from tmplargs to main
+a7b31d694812 HEAD@{998}: commit (amend): [CodeCompletion] Signature help for template argument lists
+2142ae80cf59 HEAD@{999}: commit (amend): [CodeCompletion] Signature help for template argument lists
+4669c22c0e70 HEAD@{1000}: commit (amend): [CodeCompletion] Signature help for template argument lists
+99217d405b2b HEAD@{1001}: commit (amend): [CodeCompletion] Signature help for template argument lists
+86fa6ad9fb2b HEAD@{1002}: commit (amend): [CodeCompletion] Signature help for template argument lists
+0a7d62a75abf HEAD@{1003}: commit (amend): [CodeCompletion] Signature help for template argument lists
+8b0170fa11c1 HEAD@{1004}: commit: [CodeCompletion] Signature help for template argument lists
+6f1a501fddae HEAD@{1005}: checkout: moving from main to tmplargs
+6f1a501fddae HEAD@{1006}: reset: moving to HEAD
+6f1a501fddae HEAD@{1007}: checkout: moving from aggregates to main
+9cf82ca7e4ee HEAD@{1008}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+c9f6b6b3f6a8 HEAD@{1009}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+7b37b2f933bd HEAD@{1010}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+e78f39a12189 HEAD@{1011}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+985a3b182774 HEAD@{1012}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+a7ab012a8ff1 HEAD@{1013}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+84c5ef8d6646 HEAD@{1014}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+7e2d55fea796 HEAD@{1015}: rebase (finish): returning to refs/heads/aggregates
+7e2d55fea796 HEAD@{1016}: rebase (pick): [CodeCompletion] Signature help for aggregate initialization.
+b245d1eaec2d HEAD@{1017}: rebase (start): checkout bracehelp
+6175a4ae0cfc HEAD@{1018}: checkout: moving from bracehelp to aggregates
+b245d1eaec2d HEAD@{1019}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+f648b926a983 HEAD@{1020}: checkout: moving from aggregates to bracehelp
+6175a4ae0cfc HEAD@{1021}: commit: [CodeCompletion] Signature help for aggregate initialization.
+f648b926a983 HEAD@{1022}: checkout: moving from bracehelp to aggregates
+f648b926a983 HEAD@{1023}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+d830368b01ba HEAD@{1024}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+3fe02e425768 HEAD@{1025}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+3158a41d01e1 HEAD@{1026}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+8e451de571e7 HEAD@{1027}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+b35aa36a3e3f HEAD@{1028}: commit: [CodeCompletion] Signature help for braced constructor calls
+6f1a501fddae HEAD@{1029}: checkout: moving from main to bracehelp
+6f1a501fddae HEAD@{1030}: checkout: moving from completeinit to main
+347a926ee355 (completeinit) HEAD@{1031}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+9babb0590695 HEAD@{1032}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+91e9b7b90b4f HEAD@{1033}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+0e1023621e0f HEAD@{1034}: commit: [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+6f1a501fddae HEAD@{1035}: checkout: moving from main to completeinit
+6f1a501fddae HEAD@{1036}: checkout: moving from configcompiler to main
+0fa6fc0238fe HEAD@{1037}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+8205faff5871 HEAD@{1038}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+27055788e902 HEAD@{1039}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+f9bdd0229665 HEAD@{1040}: commit: [clangd] Add CompileFlags.Compiler option to override argv0
+6f1a501fddae HEAD@{1041}: checkout: moving from main to configcompiler
+6f1a501fddae HEAD@{1042}: checkout: moving from manglefilename to main
+b3f0e3eeccc0 (manglefilename) HEAD@{1043}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+22ea16ea69e9 HEAD@{1044}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+8325fd69d14a HEAD@{1045}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+0b435ba816ae HEAD@{1046}: commit: [clangd] Adjust compile flags so they work when applied to other file(type)s.
+6f1a501fddae HEAD@{1047}: checkout: moving from main to manglefilename
+6f1a501fddae HEAD@{1048}: checkout: moving from tidydiags to main
+53abaad295f4 HEAD@{1049}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+8daae4149924 HEAD@{1050}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+95f3d66f621b HEAD@{1051}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+6e4e13e32e9a HEAD@{1052}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+b80c98fe991c HEAD@{1053}: commit: [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+6f1a501fddae HEAD@{1054}: checkout: moving from main to tidydiags
+6f1a501fddae HEAD@{1055}: rebase (finish): returning to refs/heads/main
+6f1a501fddae HEAD@{1056}: rebase (pick): [clangd] Fix typo in test. NFC
+dfa2ad1ad858 HEAD@{1057}: rebase (start): checkout origin/main
+e5cc3319d413 HEAD@{1058}: rebase (finish): returning to refs/heads/main
+e5cc3319d413 HEAD@{1059}: rebase (pick): [clangd] Fix typo in test. NFC
+e751d97863fb HEAD@{1060}: rebase (start): checkout origin/main
+be44f91f4fca HEAD@{1061}: commit: [clangd] Fix typo in test. NFC
+c2f2bb066b83 HEAD@{1062}: reset: moving to HEAD
+c2f2bb066b83 HEAD@{1063}: rebase (finish): returning to refs/heads/main
+c2f2bb066b83 HEAD@{1064}: rebase (start): checkout origin/main
+62bcb75ce510 HEAD@{1065}: checkout: moving from usingtype to main
+af27466c5039 (usingtype) HEAD@{1066}: commit (amend): Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+bbc902a8436d HEAD@{1067}: revert: Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+cc56c66f27e1 HEAD@{1068}: revert: Revert "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+565c17574dd0 HEAD@{1069}: rebase (finish): returning to refs/heads/usingtype
+565c17574dd0 HEAD@{1070}: rebase (start): checkout origin/main
+e1600db19d63 HEAD@{1071}: rebase (finish): returning to refs/heads/usingtype
+e1600db19d63 HEAD@{1072}: rebase (pick): [AST] Add UsingType: a sugar type for types found via UsingDecl
+eb66f0662ad9 HEAD@{1073}: rebase (start): checkout origin/main
+e5706481005a HEAD@{1074}: commit (amend): [AST] Add UsingType: a sugar type for types found via UsingDecl
+c11ab3c47b88 HEAD@{1075}: rebase (finish): returning to refs/heads/usingtype
+c11ab3c47b88 HEAD@{1076}: rebase (pick): [AST] Add UsingType: a sugar type for types found via UsingDecl
+9cd55c7c3463 HEAD@{1077}: rebase (start): checkout origin/main
+77701d00dbf1 HEAD@{1078}: commit (amend): [AST] Add UsingType: a sugar type for types found via UsingDecl
+484ad728d0b4 HEAD@{1079}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+38567f18b381 HEAD@{1080}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+73794c07c44c HEAD@{1081}: rebase (finish): returning to refs/heads/usingtype
+73794c07c44c HEAD@{1082}: rebase (pick): [AST] Add a sugar type for types found via UsingDecl
+02fc8d5c9eb0 HEAD@{1083}: rebase (start): checkout origin/main
+528e4f3170f7 HEAD@{1084}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+06aa0ecaf0ad HEAD@{1085}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+eb52127d5587 HEAD@{1086}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+383df0a0d6e6 HEAD@{1087}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+c4f8be2c2d68 HEAD@{1088}: rebase (continue) (finish): returning to refs/heads/usingtype
+c4f8be2c2d68 HEAD@{1089}: rebase (continue): [AST] Add a sugar type for types found via UsingDecl
+a596a5fc128b HEAD@{1090}: rebase (start): checkout origin/main
+25184d506c43 HEAD@{1091}: checkout: moving from main to usingtype
+62bcb75ce510 HEAD@{1092}: commit: [AST] Add more testcases to QualTypeNamesTest. NFC
+32dede65ae98 HEAD@{1093}: rebase (finish): returning to refs/heads/main
+32dede65ae98 HEAD@{1094}: rebase (pick): [AST] Fix QualTypeNamesTest, which was spuriously passing
+509153f1e7d1 HEAD@{1095}: rebase (start): checkout origin/main
+8b9423dcec0a HEAD@{1096}: commit: [AST] Fix QualTypeNamesTest, which was spuriously passing
+ebed0ca71561 HEAD@{1097}: rebase (finish): returning to refs/heads/main
+ebed0ca71561 HEAD@{1098}: rebase (start): checkout origin/main
+6fef0ffa14a3 HEAD@{1099}: checkout: moving from usingtype to main
+25184d506c43 HEAD@{1100}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+63d52ad6d61f HEAD@{1101}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+c0adf4433852 HEAD@{1102}: checkout: moving from origin to usingtype
+8491272d5f8b (origin) HEAD@{1103}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+58f8efe72279 HEAD@{1104}: rebase (finish): returning to refs/heads/origin
+58f8efe72279 HEAD@{1105}: rebase (pick): [clangd] Extend SymbolOrigin, stop serializing it
+e7007b69d43b (fixx) HEAD@{1106}: rebase (start): checkout origin/main
+ddcc1d2c88de HEAD@{1107}: checkout: moving from fixx to origin
+e7007b69d43b (fixx) HEAD@{1108}: rebase (finish): returning to refs/heads/fixx
+e7007b69d43b (fixx) HEAD@{1109}: rebase (pick): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+54fc9eb9b313 HEAD@{1110}: rebase (start): checkout origin/main
+563ef9895a46 HEAD@{1111}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+eb9db3287358 HEAD@{1112}: rebase (finish): returning to refs/heads/fixx
+eb9db3287358 HEAD@{1113}: rebase (pick): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+529833377ccd (block) HEAD@{1114}: rebase (start): checkout origin/main
+9344dda72035 HEAD@{1115}: checkout: moving from block to fixx
+529833377ccd (block) HEAD@{1116}: rebase (finish): returning to refs/heads/block
+529833377ccd (block) HEAD@{1117}: rebase (pick): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+a908ca6603ab HEAD@{1118}: rebase (start): checkout origin/main
+e65ea60537a7 HEAD@{1119}: checkout: moving from asyncindex to block
+747908384732 (asyncindex) HEAD@{1120}: rebase (continue) (finish): returning to refs/heads/asyncindex
+747908384732 (asyncindex) HEAD@{1121}: rebase (continue): [clangd] Proof of concept: indexing after the preamble is built
+a5927737daeb HEAD@{1122}: rebase (start): checkout origin/main
+3f8dfb604b16 HEAD@{1123}: checkout: moving from shared to asyncindex
+6917f87b3c7c (shared) HEAD@{1124}: rebase (finish): returning to refs/heads/shared
+6917f87b3c7c (shared) HEAD@{1125}: rebase (pick): [clangd] Cleanup unneeded use of shared_ptr. NFC
+4299d8d0ce42 HEAD@{1126}: rebase (start): checkout origin/main
+998c40e04bec HEAD@{1127}: commit: [clangd] Cleanup unneeded use of shared_ptr. NFC
+6fef0ffa14a3 HEAD@{1128}: checkout: moving from main to shared
+6fef0ffa14a3 HEAD@{1129}: checkout: moving from asyncindex to main
+3f8dfb604b16 HEAD@{1130}: commit (amend): [clangd] Proof of concept: indexing after the preamble is built
+69244a114c0c HEAD@{1131}: commit (amend): [clangd] Proof of concept: indexing after the preamble is built
+e0ed01382993 HEAD@{1132}: commit: [clangd] Proof of concept: indexing after the preamble is built
+6fef0ffa14a3 HEAD@{1133}: checkout: moving from main to asyncindex
+6fef0ffa14a3 HEAD@{1134}: reset: moving to HEAD
+6fef0ffa14a3 HEAD@{1135}: reset: moving to HEAD
+6fef0ffa14a3 HEAD@{1136}: reset: moving to HEAD
+6fef0ffa14a3 HEAD@{1137}: reset: moving to HEAD
+6fef0ffa14a3 HEAD@{1138}: checkout: moving from main to main
+6fef0ffa14a3 HEAD@{1139}: rebase (finish): returning to refs/heads/main
+6fef0ffa14a3 HEAD@{1140}: rebase (start): checkout origin/main
+26f6fbe2be1d HEAD@{1141}: checkout: moving from ccedit to main
+782052f2decf (fork/ccedit, ccedit) HEAD@{1142}: commit: [clangd] Prototype: code action to edit compile commands
+26f6fbe2be1d HEAD@{1143}: checkout: moving from main to ccedit
+26f6fbe2be1d HEAD@{1144}: reset: moving to origin/main
+ac431fc2cdf1 (incomplete) HEAD@{1145}: reset: moving to origin/main
+c797aa934727 HEAD@{1146}: revert: Revert "Revert "[Symbolizer][Debuginfo] Add debuginfod client to llvm-symbolizer.""
+afa3c14e2ff9 HEAD@{1147}: checkout: moving from block to main
+e65ea60537a7 HEAD@{1148}: commit (amend): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+c416e5d69d7e HEAD@{1149}: commit (amend): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+2c1e87eae0e2 HEAD@{1150}: commit: [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+afa3c14e2ff9 HEAD@{1151}: checkout: moving from main to block
+afa3c14e2ff9 HEAD@{1152}: checkout: moving from fixx to main
+9344dda72035 HEAD@{1153}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+fb15c379c1f0 HEAD@{1154}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+be240d2b0505 HEAD@{1155}: commit: [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+ac431fc2cdf1 (incomplete) HEAD@{1156}: checkout: moving from incomplete to fixx
+ac431fc2cdf1 (incomplete) HEAD@{1157}: rebase (finish): returning to refs/heads/incomplete
+ac431fc2cdf1 (incomplete) HEAD@{1158}: rebase (pick): [clangd] ... and mark a new test as -fno-ms-compatibility too
+30fc88bf1dc1 HEAD@{1159}: rebase (start): checkout origin/main
+d3aa8d688374 HEAD@{1160}: commit (amend): [clangd] ... and mark a new test as -fno-ms-compatibility too
+03d0b9092b60 HEAD@{1161}: commit: [clangd] ... and mark a new test as -fno-ms-compatibility too
+1a68c14b577f HEAD@{1162}: reset: moving to HEAD
+1a68c14b577f HEAD@{1163}: rebase (finish): returning to refs/heads/incomplete
+1a68c14b577f HEAD@{1164}: rebase (pick): [clangd] Restore -fno-ms-compatibility to tests
+8d897ec91528 HEAD@{1165}: rebase (start): checkout origin/main
+ac5910467704 HEAD@{1166}: commit: [clangd] Restore -fno-ms-compatibility to tests
+c25ea488a39a HEAD@{1167}: reset: moving to HEAD
+c25ea488a39a HEAD@{1168}: rebase (finish): returning to refs/heads/incomplete
+c25ea488a39a HEAD@{1169}: rebase (pick): [clangd] Include-fixer: handle more "incomplete type" diags.
+a55e51f9a64c HEAD@{1170}: rebase (start): checkout origin/main
+11a2f06c37cc HEAD@{1171}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags.
+8182fffc0500 HEAD@{1172}: rebase (continue) (finish): returning to refs/heads/incomplete
+8182fffc0500 HEAD@{1173}: rebase (continue): [clangd] Include-fixer: handle more "incomplete type" diags.
+86caf517bf05 HEAD@{1174}: rebase (start): checkout origin/main
+0958968acbe0 HEAD@{1175}: checkout: moving from incompletenfc to incomplete
+a8bf389f4146 (incompletenfc) HEAD@{1176}: rebase (finish): returning to refs/heads/incompletenfc
+a8bf389f4146 (incompletenfc) HEAD@{1177}: rebase (pick): [clangd] Clean up some include-fixer tests. NFC
+3ed47bcc9618 HEAD@{1178}: rebase (start): checkout origin/main
+76820d557062 HEAD@{1179}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+c28420e6737b HEAD@{1180}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+b48226a052b2 HEAD@{1181}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+0958968acbe0 HEAD@{1182}: checkout: moving from incomplete to incompletenfc
+0958968acbe0 HEAD@{1183}: checkout: moving from main to incomplete
+afa3c14e2ff9 HEAD@{1184}: checkout: moving from indeximplicit to main
+0d64c65efac9 (indeximplicit) HEAD@{1185}: cherry-pick: [clangd] Indexing of standard library
+ee26e0ba082e (implicitc) HEAD@{1186}: checkout: moving from implicitc to indeximplicit
+ee26e0ba082e (implicitc) HEAD@{1187}: commit (amend): [clangd] Include fixer for missing functions in C
+9ac5d003594e HEAD@{1188}: commit (amend): [clangd] Include fixer for missing functions in C
+3b4429acb859 HEAD@{1189}: commit (amend): [clangd] Include fixer for missing functions in C
+1a75bc322127 HEAD@{1190}: commit (amend): [clangd] Include fixer for missing functions in C
+94ab31f3c7a8 HEAD@{1191}: commit (amend): [clangd] Include fixer for missing functions in C
+86494fa881eb HEAD@{1192}: commit: [clangd] Include fixer for missing functions in C
+afa3c14e2ff9 HEAD@{1193}: checkout: moving from main to implicitc
+afa3c14e2ff9 HEAD@{1194}: rebase (finish): returning to refs/heads/main
+afa3c14e2ff9 HEAD@{1195}: rebase (start): checkout origin/main
+d4865393b5da HEAD@{1196}: checkout: moving from incomplete to main
+0958968acbe0 HEAD@{1197}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+aa89c6b2a300 HEAD@{1198}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+153236d44e9a HEAD@{1199}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+3f0f560caf3a HEAD@{1200}: commit: [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+d4865393b5da HEAD@{1201}: checkout: moving from main to incomplete
+d4865393b5da HEAD@{1202}: reset: moving to HEAD
+d4865393b5da HEAD@{1203}: rebase (finish): returning to refs/heads/main
+d4865393b5da HEAD@{1204}: rebase (start): checkout origin/main
+e7f53ec78fe8 HEAD@{1205}: checkout: moving from tblgen to main
+7ef23188fe95 (tblgen) HEAD@{1206}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+6bdf61f016e3 HEAD@{1207}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+e249c35c3fb4 HEAD@{1208}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+fcf5c9f5bf33 HEAD@{1209}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+7b3888a32700 HEAD@{1210}: rebase (continue) (finish): returning to refs/heads/tblgen
+7b3888a32700 HEAD@{1211}: rebase (continue): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+4afae6f7c7f6 HEAD@{1212}: rebase (start): checkout origin/main
+34b10022310a HEAD@{1213}: commit: [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+e7f53ec78fe8 HEAD@{1214}: checkout: moving from main to tblgen
+e7f53ec78fe8 HEAD@{1215}: checkout: moving from two to main
+c56122daac76 HEAD@{1216}: reset: moving to HEAD
+c56122daac76 HEAD@{1217}: commit (amend): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+2409b3d46f6c HEAD@{1218}: rebase (finish): returning to refs/heads/two
+2409b3d46f6c HEAD@{1219}: rebase (pick): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+2676759bf22e (morefix) HEAD@{1220}: rebase (start): checkout origin/main
+ad885f5a3eab (arcpatch-D112996) HEAD@{1221}: checkout: moving from morefix to two
+2676759bf22e (morefix) HEAD@{1222}: rebase (finish): returning to refs/heads/morefix
+2676759bf22e (morefix) HEAD@{1223}: rebase (pick): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+b73cf6207efa HEAD@{1224}: rebase (start): checkout origin/main
+da7ff2db120f HEAD@{1225}: rebase (finish): returning to refs/heads/morefix
+da7ff2db120f HEAD@{1226}: rebase (pick): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+77b2bb55671a HEAD@{1227}: rebase (start): checkout origin/main
+8bf667957ed0 HEAD@{1228}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+56f023ff10d2 HEAD@{1229}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+805bac439319 HEAD@{1230}: checkout: moving from origin to morefix
+ddcc1d2c88de HEAD@{1231}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+e4568ef854df HEAD@{1232}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+9099df1707fe HEAD@{1233}: checkout: moving from stdlib to origin
+cdfb640fe9e8 (stdlib) HEAD@{1234}: commit (amend): [clangd] Indexing of standard library
+5c14772f82eb HEAD@{1235}: commit (amend): [clangd] Indexing of standard library
+9bcdbb99a75b HEAD@{1236}: commit (amend): [clangd] WIP various stdlib indexing stuff
+3e38a40b3f17 HEAD@{1237}: commit (amend): [clangd] WIP various stdlib indexing stuff
+4ac5a41a65fc HEAD@{1238}: rebase (finish): returning to refs/heads/stdlib
+4ac5a41a65fc HEAD@{1239}: rebase (pick): [clangd] WIP various stdlib indexing stuff
+e1b9d805325b HEAD@{1240}: rebase (start): checkout origin/main
+5330f525f264 (arcpatch-D105177) HEAD@{1241}: checkout: moving from arcpatch-D105177 to stdlib
+5330f525f264 (arcpatch-D105177) HEAD@{1242}: checkout: moving from reserved to arcpatch-D105177
+18cd067d0bfa (reserved) HEAD@{1243}: commit (amend): [clangd] Don't index __reserved_names in headers.
+06dd586e7297 HEAD@{1244}: commit (amend): [clangd] Don't index __reserved_names in headers.
+e58aab51c464 HEAD@{1245}: commit (amend): [clangd] Don't index __reserved_names in headers.
+05a7bfb157fc HEAD@{1246}: commit: [clangd] Don't index __reserved_names in headers.
+e7f53ec78fe8 HEAD@{1247}: checkout: moving from main to reserved
+e7f53ec78fe8 HEAD@{1248}: checkout: moving from origin to main
+9099df1707fe HEAD@{1249}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+1557821a2bd2 HEAD@{1250}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+8c3bd3cc7478 HEAD@{1251}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+cb761c799928 HEAD@{1252}: commit: [clangd] Extend SymbolOrigin, stop serializing it
+e7f53ec78fe8 HEAD@{1253}: checkout: moving from main to origin
+e7f53ec78fe8 HEAD@{1254}: rebase (finish): returning to refs/heads/main
+e7f53ec78fe8 HEAD@{1255}: rebase (start): checkout origin/main
+afc9e7517ada HEAD@{1256}: checkout: moving from arcpatch-D105177 to main
+5330f525f264 (arcpatch-D105177) HEAD@{1257}: commit (amend): [clangd] WIP various stdlib indexing stuff
+4c58226488ee HEAD@{1258}: commit (amend): [clangd] WIP various stdlib indexing stuff
+ffbc79cbcc54 HEAD@{1259}: commit (amend): [clangd] WIP various stdlib indexing stuff
+5d5179621ede HEAD@{1260}: checkout: moving from main to arcpatch-D105177
+afc9e7517ada HEAD@{1261}: rebase (finish): returning to refs/heads/main
+afc9e7517ada HEAD@{1262}: rebase (start): checkout origin/main
+f764a1a5bd7c HEAD@{1263}: checkout: moving from arcpatch-D105177 to main
+5d5179621ede HEAD@{1264}: reset: moving to HEAD
+5d5179621ede HEAD@{1265}: rebase (finish): returning to refs/heads/arcpatch-D105177
+5d5179621ede HEAD@{1266}: rebase (pick): [clangd] Implemented indexing of standard library
+25c7ec4fc622 HEAD@{1267}: rebase (start): checkout origin/main
+7f2bbbd16a82 HEAD@{1268}: commit: [clangd] Implemented indexing of standard library
+15acaad79d6e HEAD@{1269}: checkout: moving from main to arcpatch-D105177
+f764a1a5bd7c HEAD@{1270}: checkout: moving from morefix to main
+805bac439319 HEAD@{1271}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+c74d8a0e6f33 HEAD@{1272}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+86d15e9770ca HEAD@{1273}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+a46d34a114b3 HEAD@{1274}: commit: [clangd] Add fixes for clang "include <foo.h>" diagnostics
+f764a1a5bd7c HEAD@{1275}: checkout: moving from main to morefix
+f764a1a5bd7c HEAD@{1276}: checkout: moving from usingtype to main
+c0adf4433852 HEAD@{1277}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+661fde2dfe7c HEAD@{1278}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+f38cd8c69f6d HEAD@{1279}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+4b8286a14790 HEAD@{1280}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+480e5803b30f HEAD@{1281}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+06cc1d22bf04 HEAD@{1282}: rebase (finish): returning to refs/heads/usingtype
+06cc1d22bf04 HEAD@{1283}: rebase (pick): [AST] Add a sugar type for types found via UsingDecl
+c133fb321f7c HEAD@{1284}: rebase (start): checkout origin/main
+8545d9204be1 HEAD@{1285}: rebase (abort): updating HEAD
+8545d9204be1 HEAD@{1286}: rebase (abort): updating HEAD
+8545d9204be1 HEAD@{1287}: checkout: moving from main to usingtype
+f764a1a5bd7c HEAD@{1288}: rebase (finish): returning to refs/heads/main
+f764a1a5bd7c HEAD@{1289}: rebase (pick): [clangd] Avoid possible crash: apply configuration after binding methods
+a6f53afbcb4d HEAD@{1290}: rebase (finish): returning to refs/heads/main
+a6f53afbcb4d HEAD@{1291}: rebase (start): checkout origin/main
+5fedbd5b1815 HEAD@{1292}: checkout: moving from main to usingtype
+5fedbd5b1815 HEAD@{1293}: checkout: moving from token to main
+3878ad5e448c (token) HEAD@{1294}: commit: xxx token
+5fedbd5b1815 HEAD@{1295}: checkout: moving from main to token
+5fedbd5b1815 HEAD@{1296}: rebase (finish): returning to refs/heads/main
+5fedbd5b1815 HEAD@{1297}: rebase (start): checkout origin/main
+e56d680fe870 HEAD@{1298}: checkout: moving from iwyustdlib to main
+e56d680fe870 HEAD@{1299}: checkout: moving from main to iwyustdlib
+e56d680fe870 HEAD@{1300}: rebase (finish): returning to refs/heads/main
+e56d680fe870 HEAD@{1301}: rebase (start): checkout origin/main
+4fb62e138398 HEAD@{1302}: checkout: moving from placeholders to main
+8ac9d2ae5839 (placeholders) HEAD@{1303}: rebase (finish): returning to refs/heads/placeholders
+8ac9d2ae5839 (placeholders) HEAD@{1304}: rebase (pick): [clangd] Fix function-arg-placeholder suppression with macros.
+ebda5e1e521f HEAD@{1305}: checkout: moving from main to placeholders
+ebda5e1e521f HEAD@{1306}: rebase (finish): returning to refs/heads/main
+ebda5e1e521f HEAD@{1307}: rebase (start): checkout origin/main
+48b67dca2ccc HEAD@{1308}: checkout: moving from two to main
+ad885f5a3eab (arcpatch-D112996) HEAD@{1309}: checkout: moving from arcpatch-D112996 to two
+63667c1896e1 HEAD@{1310}: rebase (finish): returning to refs/heads/arcpatch-D112996
+63667c1896e1 HEAD@{1311}: rebase (pick): [clangd] Trace per-token time in clangd --check
+f7500a4ef7bd HEAD@{1312}: rebase (pick): [CodeCompletion] Generally consider header files without extension
+5fbcf677347e HEAD@{1313}: checkout: moving from main to arcpatch-D112996
+48b67dca2ccc HEAD@{1314}: rebase (finish): returning to refs/heads/main
+48b67dca2ccc HEAD@{1315}: rebase (start): checkout origin/main
+627fa0b9a897 HEAD@{1316}: reset: moving to HEAD
+627fa0b9a897 HEAD@{1317}: checkout: moving from enum to main
+5880c835bdbe (enum) HEAD@{1318}: reset: moving to HEAD
+5880c835bdbe (enum) HEAD@{1319}: reset: moving to HEAD
+5880c835bdbe (enum) HEAD@{1320}: rebase (finish): returning to refs/heads/enum
+5880c835bdbe (enum) HEAD@{1321}: rebase (pick): [Sema] Avoid crash in CheckEnumConstant with contains-error expressions
+6a5e08cc4a5c (redecl) HEAD@{1322}: rebase (finish): returning to refs/heads/redecl
+6a5e08cc4a5c (redecl) HEAD@{1323}: rebase (pick): [AST] injected-class-name is not a redecl, even in template specializations
+627fa0b9a897 HEAD@{1324}: checkout: moving from main to redecl
+627fa0b9a897 HEAD@{1325}: rebase (finish): returning to refs/heads/main
+627fa0b9a897 HEAD@{1326}: rebase (start): checkout origin/main
+f06e33298266 HEAD@{1327}: rebase (abort): updating HEAD
+f06e33298266 HEAD@{1328}: rebase (abort): updating HEAD
+f06e33298266 HEAD@{1329}: checkout: moving from specialfiles to main
+73453e7adecb (specialfiles) HEAD@{1330}: rebase (finish): returning to refs/heads/specialfiles
+73453e7adecb (specialfiles) HEAD@{1331}: rebase (pick): [clangd] Avoid expensive checks of buffer names in IncludeCleaner
+de7494a33a5c (constcrash) HEAD@{1332}: rebase (finish): returning to refs/heads/constcrash
+de7494a33a5c (constcrash) HEAD@{1333}: rebase (pick): [AST] fail rather than crash when const evaluating invalid c++ foreach
+f06e33298266 HEAD@{1334}: checkout: moving from main to specialfiles
+f06e33298266 HEAD@{1335}: rebase (finish): returning to refs/heads/main
+f06e33298266 HEAD@{1336}: rebase (start): checkout origin/main
+9cc08cb02fdc (crashtest) HEAD@{1337}: checkout: moving from crashtest to constcrash
+9cc08cb02fdc (crashtest) HEAD@{1338}: rebase (finish): returning to refs/heads/crashtest
+9cc08cb02fdc (crashtest) HEAD@{1339}: rebase (pick): [clangd] Add integration test for crash handling
+51be7061d025 HEAD@{1340}: reset: moving to HEAD
+51be7061d025 HEAD@{1341}: checkout: moving from main to crashtest
+51be7061d025 HEAD@{1342}: commit: [clangd] Remove tricky integration test that flakes/fails on some platforms.
+4373f3595f8e HEAD@{1343}: rebase (finish): returning to refs/heads/main
+4373f3595f8e HEAD@{1344}: rebase (start): checkout origin/main
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1345}: checkout: moving from timer to main
+aa1ac2ae451e (flush) HEAD@{1346}: checkout: moving from flush to timer
+aa1ac2ae451e (flush) HEAD@{1347}: rebase (finish): returning to refs/heads/flush
+aa1ac2ae451e (flush) HEAD@{1348}: rebase (pick): [clangd] Flush stderr after signal handlers run, so we always get the full stack/crash info
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1349}: checkout: moving from main to flush
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1350}: rebase (finish): returning to refs/heads/main
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1351}: rebase (start): checkout origin/main
+4e91035387fa HEAD@{1352}: checkout: moving from arcpatch-D109506_1 to main
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1353}: rebase (finish): returning to refs/heads/arcpatch-D109506_1
+045695f85cb8 (arcpatch-D109506_1) HEAD@{1354}: rebase (pick): [clangd] Print current request context along with the stack trace
+980c7f32490b HEAD@{1355}: checkout: moving from arcpatch-D111318 to arcpatch-D109506_1
+a85b661d2ada (arcpatch-D111318) HEAD@{1356}: rebase (finish): returning to refs/heads/arcpatch-D111318
+a85b661d2ada (arcpatch-D111318) HEAD@{1357}: rebase (pick): [clang][clangd] Improve signature help for variadic functions.
+3964c1db915b HEAD@{1358}: checkout: moving from main to arcpatch-D111318
+4e91035387fa HEAD@{1359}: rebase (finish): returning to refs/heads/main
+4e91035387fa HEAD@{1360}: rebase (pick): [Support] Trim #include after b06df22
+93c1b3caf052 HEAD@{1361}: reset: moving to HEAD
+93c1b3caf052 HEAD@{1362}: rebase (finish): returning to refs/heads/main
+93c1b3caf052 HEAD@{1363}: rebase (start): checkout origin/main
+c15bbdeafffb HEAD@{1364}: checkout: moving from arcpatch-D110825 to main
+82fbd3412fec (arcpatch-D110825) HEAD@{1365}: commit: [clangd] Handle members of anon structs in SelectionTree
+68e56bd320d7 HEAD@{1366}: checkout: moving from main to arcpatch-D110825
+c15bbdeafffb HEAD@{1367}: rebase (finish): returning to refs/heads/main
+c15bbdeafffb HEAD@{1368}: rebase (start): checkout origin/main
+bb9333c3504a HEAD@{1369}: checkout: moving from uid to main
+22555bafe90d (uid) HEAD@{1370}: rebase (finish): returning to refs/heads/uid
+22555bafe90d (uid) HEAD@{1371}: rebase (pick): [VFS] InMemoryFilesystem's UniqueIDs are a function of path and content.
+722e705f72dd (arcpatch-D110324) HEAD@{1372}: checkout: moving from arcpatch-D110324 to uid
+722e705f72dd (arcpatch-D110324) HEAD@{1373}: rebase (finish): returning to refs/heads/arcpatch-D110324
+722e705f72dd (arcpatch-D110324) HEAD@{1374}: rebase (start): checkout origin/main
+eb209c13cce9 HEAD@{1375}: rebase (finish): returning to refs/heads/arcpatch-D110324
+eb209c13cce9 HEAD@{1376}: rebase (pick): clangd: Do not report inline overrides twice
+5685eb950da7 HEAD@{1377}: checkout: moving from main to arcpatch-D110324
+bb9333c3504a HEAD@{1378}: rebase (finish): returning to refs/heads/main
+bb9333c3504a HEAD@{1379}: rebase (start): checkout origin/main
+61cc873a8ef1 HEAD@{1380}: checkout: moving from arcpatch-D109506 to main