diff --git a/clang-tools-extra/clangd/CodeComplete.cpp b/clang-tools-extra/clangd/CodeComplete.cpp
--- a/clang-tools-extra/clangd/CodeComplete.cpp
+++ b/clang-tools-extra/clangd/CodeComplete.cpp
@@ -896,10 +896,7 @@
 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 @@
                                     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 @@
                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 @@
            "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
--- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
@@ -1294,6 +1294,25 @@
   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
--- a/clang/include/clang/Sema/CodeCompleteConsumer.h
+++ b/clang/include/clang/Sema/CodeCompleteConsumer.h
@@ -1018,6 +1018,9 @@
 
       /// 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 @@
       /// 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 @@
       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
--- a/clang/lib/Sema/CodeCompleteConsumer.cpp
+++ b/clang/lib/Sema/CodeCompleteConsumer.cpp
@@ -508,6 +508,7 @@
     return Type;
 
   case CK_Template:
+  case CK_Aggregate:
     return nullptr;
   }
 
@@ -517,11 +518,80 @@
 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
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -2817,14 +2817,18 @@
                        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 @@
       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 @@
 
     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 @@
   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 @@
                                        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 @@
 
   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 @@
     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 @@
   // 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 @@
   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 @@
                                                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
--- a/clang/test/CodeCompletion/ctor-signature.cpp
+++ b/clang/test/CodeCompletion/ctor-signature.cpp
@@ -42,13 +42,29 @@
 // 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 b/tl
new file mode 100644
--- /dev/null
+++ b/tl
@@ -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 different "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 different 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 different 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 differently. 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