[CodeCompletion] Signature help for aggregate initialization.

[sammccall]

Summary

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

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

Related bugs:

• https://github.com/clangd/clangd/issues/965
• https://github.com/clangd/clangd/issues/306

[kadircet]

clang-tools-extra/clangd/CodeComplete.cpp

1190

we were never recording unnamed params before, now they'll be surfaced during comment code completions. can you either keep dropping them here or on the code completion generation side (~line 1997)

clang/include/clang/Sema/CodeCompleteConsumer.h

1075

we don't have assertions in other cases, why here? (i think we should have it in other cases too, just wondering if there are any valid states where we construct an overloadcandidate from nullptr)

clang/lib/Sema/CodeCompleteConsumer.cpp

523

i think this is only valid for c++17 onwards If the number of initializer clauses exceeds the number of members and bases (since C++17) to initialize, the program is ill-formed. (same for param type/decl)

it gets even more complicated, since one doesn't have to nest initialization of base class fields, e.g this is valid:

struct X
{
    int a;
    int b;
};

struct Y : X
{
    int c;
};

Y y1{ {1,2}, 3};
Y y2{ 1, 2, 3 }; // both of these set a=1, b=2, c=3

clang/lib/Sema/SemaCodeComplete.cpp

6107

also static

[sammccall]

clang-tools-extra/clangd/CodeComplete.cpp

1190

I don't think I've changed behavior here, if there's no name then the IdentifierInfo is nullptr

clang/include/clang/Sema/CodeCompleteConsumer.h

1075

I can't remember why I added it now!
I've added the others, tests still pass.

clang/lib/Sema/CodeCompleteConsumer.cpp

523

i think this is only valid for c++17 onwards

We only get here for aggregate types, and pre-C++17 those are guaranteed to have no bases.

one doesn't have to nest initialization of base class fields

Great catch, somehow I missed this in the spec. This makes things very complicated. Why on earth is this allowed?! (After some digging, compatibility with C99)

I can't see a reasonable way to support this. If it were just bases I'd drop support for them, but it applies to fields too.
The implementation difficulty is having to do full conversion-sequence checks for each element to tell whether it is a standalone element or the first in an implied nested list.

This elision is slightly discouraged (-Wmissing-braces in in -Wall) so I think it's OK to give results that are going to be a bit off if brace-elision is used.
If there are a lot of complaints we could try to detect this in future.

[sammccall]

address comments

[usaxena95]

clang/lib/Sema/SemaCodeComplete.cpp

3699

nit: const ref.

6094

Can you also add detail for out-of-order designated initialisation.
S{.c=1, .b=2, (valid C, invalid C++, ext in C++)
IIUC the current version would continue with c here. (reasoning: promoting in-order designated initialisation ?)

6132

nit: move closer to usage below.

[kadircet]

clang/include/clang/Sema/CodeCompleteConsumer.h

1095

either assert the kind and return AggregateType or change the callers below to not explicitly check for kind (and directly check if returned RecordDecl is not-null).

clang/lib/Sema/CodeCompleteConsumer.cpp

523

This elision is slightly discouraged (-Wmissing-braces in in -Wall) so I think it's OK to give results that are going to be a bit off if brace-elision is used.

If there are a lot of complaints we could try to detect this in future.

As discussed offline I second this.

569

this doesn't cover the function(proto)type case

clang/lib/Sema/SemaCodeComplete.cpp

3903–3904

isn't this and the following case actually the same? can't we just use the return type inside functiontype ?

5958

nit: early exit

6105

assert that Aggregate is of right kind?

[sammccall]

clang/lib/Sema/CodeCompleteConsumer.cpp

569

That's right. Function(Proto)Type doesn't contain decls for the parameters. Added a comment.

clang/lib/Sema/SemaCodeComplete.cpp

6094

Added a comment

The reasoning is just that's the correct behavior :-)

struct S {int a,b; };
int m = (struct S){.b=1, .a=2, 3}.b;
// now m.a is 3

[sammccall]

Address comments

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/CodeComplete.cpp

 // Returns the index of the parameter matching argument number "Arg.
 // This is usually just "Arg", except for variadic functions/templates, where
 // "Arg" might be higher than the number of parameters. When that happens, we
 // assume the last parameter is variadic and assume all further args are
 // part of it.
 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;
     }
   }
   return std::min(Arg, std::max(NumParams - 1, 0));
 }
 
if (Index) {
            "symbols with non-empty docs in the response",
            IndexRequest.IDs.size(), FetchedDocs.size());
     }
 
     llvm::sort(ScoredSignatures, [](const ScoredSignature &L,
                                     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.
       if (L.Quality.NumberOfParameters != R.Quality.NumberOfParameters)
         return L.Quality.NumberOfParameters < R.Quality.NumberOfParameters;
       if (L.Quality.NumberOfOptionalParameters !=
           R.Quality.NumberOfOptionalParameters)
         return L.Quality.NumberOfOptionalParameters <
                R.Quality.NumberOfOptionalParameters;
       if (L.Quality.Kind != R.Quality.Kind) {
         using OC = CodeCompleteConsumer::OverloadCandidate;
-        switch (L.Quality.Kind) {
+        auto KindPriority = [&](OC::CandidateKind K) {
+          switch (K) {
+          case OC::CK_Aggregate:
+            return 1;
           case OC::CK_Function:
-          return true;
+            return 2;
           case OC::CK_FunctionType:
-          return R.Quality.Kind != OC::CK_Function;
+            return 3;
           case OC::CK_FunctionTemplate:
-          return false;
+            return 4;
           case OC::CK_Template:
-          assert(false && "Never see templates and other overloads mixed");
-          return false;
+            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();
       return L.Signature.label < R.Signature.label;
     });
 
     for (auto &SS : ScoredSignatures) {
       auto IndexDocIt =
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
                                  OverloadCandidate *Candidates,
                                  unsigned NumCandidates,
                                  SourceLocation OpenParLoc,
                                  bool Braced) override {
     assert(CurrentArg <= (unsigned)std::numeric_limits<int>::max() &&
            "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());
     }
   }
 
 private:
   GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

TEST(SignatureHelpTest, Constructors) {
   CheckBracedInit("S s{^};");
   CheckBracedInit("S s = {^};");
   CheckBracedInit("auto s = S{^};");
   // FIXME: doesn't work: no ExpectedType set in ParseCXXNewExpression.
   // CheckBracedInit("auto s = new S{^};");
   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;};
     struct B {B(A);};
     void f();
     int main() {
       B b({1});
       f(^);

clang/include/clang/Sema/CodeCompleteConsumer.h

enum CandidateKind {
       CK_FunctionTemplate,
 
       /// The "candidate" is actually a variable, expression, or block
       /// for which we only have a function prototype.
       CK_FunctionType,
 
       /// The candidate is a template, template arguments are being completed.
       CK_Template,
+
+      /// The candidate is aggregate initialization of a record type.
+      CK_Aggregate,
     };
 
   private:
     /// The kind of overload candidate.
     CandidateKind Kind;
 
     union {
       /// The function overload candidate, available when
       /// Kind == CK_Function.
       FunctionDecl *Function;
 
       /// The function template overload candidate, available when
       /// Kind == CK_FunctionTemplate.
       FunctionTemplateDecl *FunctionTemplate;
 
       /// The function type that describes the entity being called,
       /// when Kind == CK_FunctionType.
       const FunctionType *Type;
 
       /// 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) {}
 
     /// Determine the kind of overload candidate.
     CandidateKind getKind() const { return Kind; }
 
     /// Retrieve the function overload candidate or the templated
     /// function declaration for a function template.
     FunctionDecl *getFunction() const;
 
     /// Retrieve the function template overload candidate.
     FunctionTemplateDecl *getFunctionTemplate() const {
       assert(getKind() == CK_FunctionTemplate && "Not a function template");
       return FunctionTemplate;
     }
 
     /// Retrieve the function type of the entity, regardless of how the
     /// function is stored.
     const FunctionType *getFunctionType() const;
 
     const TemplateDecl *getTemplate() const {
       assert(getKind() == CK_Template && "Not a template");
       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 *
     CreateSignatureString(unsigned CurrentArg, Sema &S,
                           CodeCompletionAllocator &Allocator,
                           CodeCompletionTUInfo &CCTUInfo,
                           bool IncludeBriefComments, bool Braced) const;
   };

clang/lib/Sema/CodeCompleteConsumer.cpp

case CK_FunctionTemplate:
     return FunctionTemplate->getTemplatedDecl()
         ->getType()
         ->getAs<FunctionType>();
 
   case CK_FunctionType:
     return Type;
 
   case CK_Template:
+  case CK_Aggregate:
     return nullptr;
   }
 
   llvm_unreachable("Invalid CandidateKind!");
 }
 
 unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const {
   if (Kind == CK_Template)
     return Template->getTemplateParameters()->size();
-  if (const auto *FPT = dyn_cast_or_null<FunctionProtoType>(getFunctionType()))
+
+  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
 //===----------------------------------------------------------------------===//
 
 CodeCompleteConsumer::~CodeCompleteConsumer() = default;
 
 bool PrintingCodeCompleteConsumer::isResultFilteredOut(
     StringRef Filter, CodeCompletionResult Result) {

clang/lib/Sema/SemaCodeComplete.cpp

 static std::string
 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
                        FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
                        bool SuppressBlockName = false,
                        bool SuppressBlock = false,
                        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()) {
     // The argument for a dependent or non-block parameter is a placeholder
     // containing that parameter's type.
     std::string Result;
 
     if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
       Result = std::string(Param->getIdentifier()->getName());
 
     QualType Type = Param->getType();
     if (ObjCSubsts)
       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();
     } else {
       Type.getAsStringInternal(Result, Policy);
     }
     return Result;
   }
if (!Block) {
     std::string Result;
     if (!ObjCMethodParam && Param->getIdentifier())
       Result = std::string(Param->getIdentifier()->getName());
 
     QualType Type = Param->getType().getUnqualifiedType();
 
     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() != ')')
         Result += " ";
       if (Param->getIdentifier())
         Result += Param->getIdentifier()->getName();
     } else {
       Type.getAsStringInternal(Result, Policy);
const RawComment *clang::getParameterComment(
   auto FDecl = Result.getFunction();
   if (!FDecl)
     return nullptr;
   if (ArgIndex < FDecl->getNumParams())
     return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
   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,
                                        const PrintingPolicy &Policy,
                                        const FunctionDecl *Function,
                                        const FunctionProtoType *Prototype,
                                        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();
 
   for (unsigned P = Start; P != NumParams; ++P) {
     if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
       // When we see an optional default argument, put that argument and
       // the remaining default arguments into a new, optional string.
CodeCompletionBuilder Result(Allocator, CCTUInfo, 1,
                                CXAvailability_Available);
 
   if (getKind() == CK_Template)
     return createTemplateSignatureString(getTemplate(), Result, CurrentArg,
                                          Policy);
 
   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()));
     }
     AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
 
     std::string Name;
     llvm::raw_string_ostream OS(Name);
     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);
+  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);
 
   return Result.TakeString();
 }
 
 unsigned clang::getMacroUsagePriority(StringRef MacroName,
                                       const LangOptions &LangOpts,

 static QualType getParamType(Sema &SemaRef,
                              ArrayRef<ResultCandidate> Candidates, unsigned N) {
 
   // Given the overloads 'Candidates' for a function call matching all arguments
   // up to N, return the type of the Nth parameter if it is the same for all
   // 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(
+            CandidateParamType.getNonReferenceType()))
+      // Two conflicting types, give up.
 
   return ParamType;
 }
 
 static QualType
 ProduceSignatureHelp(Sema &SemaRef, MutableArrayRef<ResultCandidate> Candidates,
                      unsigned CurrentArg, SourceLocation OpenParLoc,
                      bool Braced) {
if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) {
     }
   }
   mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
   QualType ParamType = ProduceSignatureHelp(*this, Results, Args.size(),
                                             OpenParLoc, /*Braced=*/false);
   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,
                                                SourceLocation OpenParLoc,
                                                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())
+  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.
 
+  if (CRD) {
     OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
-
-  for (NamedDecl *C : LookupConstructors(RD)) {
+    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);
       }
     }
-
-  SmallVector<ResultCandidate, 8> Results;
     mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
+  }
+
   return ProduceSignatureHelp(*this, Results, Args.size(), OpenParLoc, Braced);
 }
 
 QualType Sema::ProduceCtorInitMemberSignatureHelp(
     Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy,
     ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc,
     bool Braced) {
   if (!CodeCompleter)

clang/test/CodeCompletion/ctor-signature.cpp

 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:36:15 %s | FileCheck -check-prefix=CHECK-BRACED %s
 Bar b2{};
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:38:8 %s | FileCheck -check-prefix=CHECK-BRACED %s
 static int consumeBar(Bar) { return 0; }
 int b3 = consumeBar({});
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:41:22 %s | FileCheck -check-prefix=CHECK-BRACED %s
 
 struct Aggregate {
-  // FIXME: no support for aggregates yet.
-  // CHECK-AGGREGATE-NOT: OVERLOAD: Aggregate{<#const Aggregate &#>}
-  // CHECK-AGGREGATE-NOT: OVERLOAD: {{.*}}first
   int first;
   int second;
+  int third;
 };
 
-Aggregate a{};
-// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:52:13 %s | FileCheck -check-prefix=CHECK-AGGREGATE %s
-
+Aggregate a{1, 2, 3};
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:13 %s | FileCheck -check-prefix=CHECK-AGGREGATE-1 %s
+// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#int first#>, int second, int third}
+// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:16 %s | FileCheck -check-prefix=CHECK-AGGREGATE-2 %s
+// CHECK-AGGREGATE-2: OVERLOAD: Aggregate{int first, <#int second#>, int third}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:18 %s | FileCheck -check-prefix=CHECK-AGGREGATE-3 %s
+// CHECK-AGGREGATE-3: OVERLOAD: Aggregate{int first, int second, <#int third#>}
+
+Aggregate d{.second=1, .first=2, 3, 4, };
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:13 %s | FileCheck -check-prefix=CHECK-DESIG-1 %s
+// CHECK-DESIG-1: OVERLOAD: Aggregate{<#int first#>, int second, int third}
+// CHECK-DESIG-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:24 %s | FileCheck -check-prefix=CHECK-DESIG-2 %s
+// CHECK-DESIG-2: OVERLOAD: Aggregate{int first, int second, <#int third#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:34 %s | FileCheck -check-prefix=CHECK-DESIG-3 %s
+// CHECK-DESIG-3: OVERLOAD: Aggregate{int first, <#int second#>, int third}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:37 %s | FileCheck -check-prefix=CHECK-DESIG-4 %s
+// CHECK-DESIG-4: OVERLOAD: Aggregate{int first, int second, <#int third#>}
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:38 %s | FileCheck -check-prefix=CHECK-DESIG-5 %s --allow-empty
+// CHECK-DESIG-5-NOT: OVERLOAD

tl

+␛[33m2a92efd0a239␛[m␛[33m (␛[m␛[1;36mHEAD -> ␛[m␛[1;32mmain␛[m␛[33m, ␛[m␛[1;31morigin/main␛[m␛[33m)␛[m HEAD@{0}: rebase (finish): returning to refs/heads/main
+␛[33m2a92efd0a239␛[m␛[33m (␛[m␛[1;36mHEAD -> ␛[m␛[1;32mmain␛[m␛[33m, ␛[m␛[1;31morigin/main␛[m␛[33m)␛[m HEAD@{1}: rebase (pick): [CodeComplete] drop unused Scope param. NFC
+␛[33m1379eb577607␛[m HEAD@{2}: rebase (start): checkout origin/main
+␛[33m1e3d96c67ff9␛[m HEAD@{3}: commit: [CodeComplete] drop unused Scope param. NFC
+␛[33m6231ef262415␛[m HEAD@{4}: rebase (finish): returning to refs/heads/main
+␛[33m6231ef262415␛[m HEAD@{5}: rebase (start): checkout origin/main
+␛[33mf1f5a85af8be␛[m HEAD@{6}: checkout: moving from aggregates to main
+␛[33mc8b1ec7561fe␛[m␛[33m (␛[m␛[1;32maggregates␛[m␛[33m)␛[m HEAD@{7}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33mfee43399f0af␛[m HEAD@{8}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33mdaf114e5c347␛[m HEAD@{9}: rebase (continue) (finish): returning to refs/heads/aggregates
+␛[33mdaf114e5c347␛[m HEAD@{10}: rebase (continue): [CodeCompletion] Signature help for aggregate initialization.
+␛[33mf2b3e25f860e␛[m␛[33m (␛[m␛[1;32mconfigcompiler␛[m␛[33m)␛[m HEAD@{11}: rebase (start): checkout origin/main
+␛[33m4f17932fb479␛[m HEAD@{12}: checkout: moving from configcompiler to aggregates
+␛[33mf2b3e25f860e␛[m␛[33m (␛[m␛[1;32mconfigcompiler␛[m␛[33m)␛[m HEAD@{13}: rebase (finish): returning to refs/heads/configcompiler
+␛[33mf2b3e25f860e␛[m␛[33m (␛[m␛[1;32mconfigcompiler␛[m␛[33m)␛[m HEAD@{14}: rebase (pick): [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33mf4ef79306cee␛[m HEAD@{15}: rebase (start): checkout origin/main
+␛[33m6443bd3db307␛[m HEAD@{16}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33m0fa6fc0238fe␛[m HEAD@{17}: reset: moving to HEAD
+␛[33m0fa6fc0238fe␛[m HEAD@{18}: checkout: moving from main to configcompiler
+␛[33mf1f5a85af8be␛[m HEAD@{19}: rebase (finish): returning to refs/heads/main
+␛[33mf1f5a85af8be␛[m HEAD@{20}: rebase (start): checkout origin/main
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{21}: checkout: moving from bracehelp to main
+␛[33ma61f34ea2502␛[m␛[33m (␛[m␛[1;32mbracehelp␛[m␛[33m)␛[m HEAD@{22}: commit: [clangd] Fix windows build after 478863ef58c7f7314e06
+␛[33m92417eaf3329␛[m HEAD@{23}: rebase (finish): returning to refs/heads/bracehelp
+␛[33m92417eaf3329␛[m HEAD@{24}: rebase (pick): [CodeCompletion] Signature help for braced constructor calls
+␛[33ma390c9905d4d␛[m HEAD@{25}: rebase (start): checkout origin/main
+␛[33m8da663369977␛[m HEAD@{26}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33m9ee52e712414␛[m HEAD@{27}: rebase (continue) (finish): returning to refs/heads/bracehelp
+␛[33m9ee52e712414␛[m HEAD@{28}: rebase (continue): [CodeCompletion] Signature help for braced constructor calls
+␛[33m364eb371012b␛[m HEAD@{29}: rebase (start): checkout origin/main
+␛[33mb245d1eaec2d␛[m HEAD@{30}: checkout: moving from iwyustdlib to bracehelp
+␛[33m478863ef58c7␛[m␛[33m (␛[m␛[1;32miwyustdlib␛[m␛[33m)␛[m HEAD@{31}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33mee8a314f09c0␛[m HEAD@{32}: rebase (finish): returning to refs/heads/iwyustdlib
+␛[33mee8a314f09c0␛[m HEAD@{33}: rebase (pick): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33mb9ed95afc4b1␛[m HEAD@{34}: rebase (start): checkout origin/main
+␛[33mf038610fb5f3␛[m HEAD@{35}: checkout: moving from insertion_point to iwyustdlib
+␛[33mfe68088d44f7␛[m␛[33m (␛[m␛[1;32minsertion_point␛[m␛[33m)␛[m HEAD@{36}: rebase (finish): returning to refs/heads/insertion_point
+␛[33mfe68088d44f7␛[m␛[33m (␛[m␛[1;32minsertion_point␛[m␛[33m)␛[m HEAD@{37}: rebase (pick): [clangd] Helper for determining member insertion point.
+␛[33m9e6f88b31a7f␛[m␛[33m (␛[m␛[1;32mtidydiags␛[m␛[33m)␛[m HEAD@{38}: rebase (start): checkout origin/main
+␛[33maacd98d5b867␛[m HEAD@{39}: checkout: moving from tidydiags to insertion_point
+␛[33m9e6f88b31a7f␛[m␛[33m (␛[m␛[1;32mtidydiags␛[m␛[33m)␛[m HEAD@{40}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33me9211c3dd6ba␛[m HEAD@{41}: rebase (finish): returning to refs/heads/tidydiags
+␛[33me9211c3dd6ba␛[m HEAD@{42}: rebase (pick): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33m7505aeefc4e6␛[m HEAD@{43}: rebase (start): checkout origin/main
+␛[33m53abaad295f4␛[m HEAD@{44}: checkout: moving from aggregates to tidydiags
+␛[33m4f17932fb479␛[m HEAD@{45}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33m9cf82ca7e4ee␛[m HEAD@{46}: checkout: moving from tmplargs to aggregates
+␛[33mcd45e8c7bc16␛[m␛[33m (␛[m␛[1;32mtmplargs␛[m␛[33m)␛[m HEAD@{47}: rebase (finish): returning to refs/heads/tmplargs
+␛[33mcd45e8c7bc16␛[m␛[33m (␛[m␛[1;32mtmplargs␛[m␛[33m)␛[m HEAD@{48}: rebase (pick): [CodeCompletion] Signature help for template argument lists
+␛[33m3a33c0b1ce0d␛[m HEAD@{49}: rebase (start): checkout origin/main
+␛[33m36da2251bd60␛[m HEAD@{50}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33mef7f8bce7503␛[m HEAD@{51}: checkout: moving from arcpatch-D116218 to tmplargs
+␛[33mf2b2aae6843b␛[m␛[33m (␛[m␛[1;32marcpatch-D116218␛[m␛[33m)␛[m HEAD@{52}: commit (amend): [clangd] Fix selection on multi-dimensional array.
+␛[33m50f8215cc9be␛[m HEAD@{53}: commit (amend): [clangd] Fix selection on multi-dimensional array. (alternate version)
+␛[33m85244a21fd16␛[m HEAD@{54}: commit (amend): [clangd] Fix selection on multi-dimensional array. (alternate version)
+␛[33m169e8e0af680␛[m HEAD@{55}: rebase (finish): returning to refs/heads/arcpatch-D116218
+␛[33m169e8e0af680␛[m HEAD@{56}: rebase (pick): [clangd] Fix selection on multi-dimensional array.
+␛[33mca271f4ef5a2␛[m HEAD@{57}: rebase (start): checkout origin/main
+␛[33m70d0857a4dea␛[m HEAD@{58}: commit: [clangd] Fix selection on multi-dimensional array.
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{59}: checkout: moving from main to arcpatch-D116218
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{60}: checkout: moving from tmplargs to main
+␛[33mef7f8bce7503␛[m HEAD@{61}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33ma7b31d694812␛[m HEAD@{62}: checkout: moving from insertion_point to tmplargs
+␛[33maacd98d5b867␛[m HEAD@{63}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33mac972fe4ff15␛[m HEAD@{64}: checkout: moving from main to insertion_point
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{65}: reset: moving to HEAD
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{66}: checkout: moving from constructor to main
+␛[33m41fbc109a1ae␛[m␛[33m (␛[m␛[1;32mconstructor␛[m␛[33m)␛[m HEAD@{67}: commit (amend): [clangd] Add code action to generate a constructor for a C++ class
+␛[33m8e709f570606␛[m HEAD@{68}: commit (amend): [clangd] Add code action to generate a constructor for a C++ class
+␛[33m456dc7755f32␛[m HEAD@{69}: commit: [clangd] Add code action to generate a constructor for a C++ class
+␛[33mac972fe4ff15␛[m HEAD@{70}: checkout: moving from insertion_point to constructor
+␛[33mac972fe4ff15␛[m HEAD@{71}: checkout: moving from constructor to insertion_point
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{72}: reset: moving to HEAD
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{73}: checkout: moving from constructor to constructor
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{74}: reset: moving to HEAD~1
+␛[33maa6435e963ca␛[m HEAD@{75}: checkout: moving from insertion_point to constructor
+␛[33mac972fe4ff15␛[m HEAD@{76}: checkout: moving from constructor to insertion_point
+␛[33maa6435e963ca␛[m HEAD@{77}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33m45d6b0cd4780␛[m HEAD@{78}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33mac972fe4ff15␛[m HEAD@{79}: checkout: moving from insertion_point to constructor
+␛[33mac972fe4ff15␛[m HEAD@{80}: checkout: moving from specialmember to insertion_point
+␛[33m60a028a904d5␛[m␛[33m (␛[m␛[1;32mspecialmember␛[m␛[33m)␛[m HEAD@{81}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m939996aed14e␛[m HEAD@{82}: checkout: moving from 939996aed14ec84df8cce3f4a5ec4988c4a1f564 to specialmember
+␛[33m939996aed14e␛[m HEAD@{83}: rebase (pick): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33mac972fe4ff15␛[m HEAD@{84}: rebase (start): checkout insertion_point
+␛[33mbbeef89ae1af␛[m HEAD@{85}: checkout: moving from specialmember to bbeef89ae1af
+␛[33mac972fe4ff15␛[m HEAD@{86}: rebase (finish): returning to refs/heads/specialmember
+␛[33mac972fe4ff15␛[m HEAD@{87}: rebase (start): checkout insertion_point
+␛[33mbbeef89ae1af␛[m HEAD@{88}: checkout: moving from insertion_point to specialmember
+␛[33mac972fe4ff15␛[m HEAD@{89}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33m0eac12f86ab3␛[m HEAD@{90}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33m156bab8c3ab7␛[m HEAD@{91}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33mda546cc68656␛[m HEAD@{92}: commit (amend): [clangd] Helper for determining member insertion point.
+␛[33m407f5558b48c␛[m HEAD@{93}: commit: [clangd] Helper for determining member insertion point.
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{94}: checkout: moving from main to insertion_point
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{95}: checkout: moving from specialmember to main
+␛[33mbbeef89ae1af␛[m HEAD@{96}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33ma66453e487e3␛[m HEAD@{97}: reset: moving to HEAD
+␛[33ma66453e487e3␛[m HEAD@{98}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m31c647f871a8␛[m HEAD@{99}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m500372f1ac6d␛[m HEAD@{100}: reset: moving to HEAD
+␛[33m500372f1ac6d␛[m HEAD@{101}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m174dac9746f1␛[m HEAD@{102}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m34bba952dadc␛[m HEAD@{103}: commit (amend): [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m8b2288785c88␛[m HEAD@{104}: commit: [clangd] Code action to declare missing move/copy constructor/assignment
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{105}: checkout: moving from main to specialmember
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{106}: checkout: moving from typeDefinition to main
+␛[33m6fbb2e3eca26␛[m␛[33m (␛[m␛[1;32mtypeDefinition␛[m␛[33m)␛[m HEAD@{107}: commit (amend): [clangd] Implement textDocument/typeDefinition
+␛[33m1ea84876711e␛[m HEAD@{108}: commit (amend): [clangd] Implement textDocument/typeDefinition
+␛[33m2bf2e73c73d9␛[m HEAD@{109}: commit (amend): [clangd] Implement textDocument/typeDefinition
+␛[33md15e5a597103␛[m HEAD@{110}: commit (amend): [clangd] Implement textDocument/typeDefinition
+␛[33m494458626828␛[m HEAD@{111}: commit: [clangd] Implement textDocument/typeDefinition
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{112}: checkout: moving from main to typeDefinition
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{113}: rebase (finish): returning to refs/heads/main
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{114}: rebase (start): checkout origin/main
+␛[33m72ea6fbc150a␛[m HEAD@{115}: checkout: moving from arraytype to main
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{116}: rebase (finish): returning to refs/heads/arraytype
+␛[33m09f8315bba39␛[m␛[33m (␛[m␛[1;32marraytype␛[m␛[33m)␛[m HEAD@{117}: rebase (pick): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+␛[33med67d5a03aaf␛[m HEAD@{118}: rebase (start): checkout origin/main
+␛[33m5c3e13fb9825␛[m HEAD@{119}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+␛[33m991036e41b3b␛[m HEAD@{120}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+␛[33m47ffbac82a3f␛[m HEAD@{121}: commit (amend): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+␛[33m9923e86a3a96␛[m HEAD@{122}: rebase (continue) (finish): returning to refs/heads/arraytype
+␛[33m9923e86a3a96␛[m HEAD@{123}: rebase (continue): [Sema] a[x] has type T when a has type T* or T[], even when T is dependent
+␛[33m15787ccd4574␛[m HEAD@{124}: rebase (start): checkout origin/main
+␛[33m1dc8f4774d34␛[m HEAD@{125}: rebase (abort): updating HEAD
+␛[33m0651768d7a19␛[m HEAD@{126}: rebase (pick): updated suggesting/coloring of call & return args & implicit operands.
+␛[33mf86d65195716␛[m HEAD@{127}: rebase (pick): updated suggesting/coloring of call & return args & implicit operands
+␛[33m3002813063a8␛[m HEAD@{128}: rebase (pick): --changed Sugesting colors for method calls/return values etc.
+␛[33m7bdf5ba01bb0␛[m HEAD@{129}: rebase (pick): fixed a coalscing bug
+␛[33m7524a1746083␛[m HEAD@{130}: rebase (pick): Add library
+␛[33mba28b47cb919␛[m HEAD@{131}: rebase (pick): Be const correct
+␛[33m1aa4098bafea␛[m HEAD@{132}: rebase (pick): Minor code cleanups
+␛[33m629281c4710d␛[m HEAD@{133}: rebase (pick): Add cast_or_null & dyn_cast_or_null
+␛[33m24c3a0a84fda␛[m HEAD@{134}: rebase (pick): Implement initializers for structs and pointers
+␛[33m2f93ba463315␛[m HEAD@{135}: rebase (pick): Rename ConstPoolPointerReference to ConstPoolPointerRef - My fingers get tired typing that much
+␛[33me58844e57ecb␛[m HEAD@{136}: rebase (pick): Improve error messages on assertion failure.
+␛[33m73eab57ce304␛[m HEAD@{137}: rebase (pick): * getExitNode() doesn't exist in method anymore
+␛[33m171cd5f1d612␛[m HEAD@{138}: rebase (pick): Added Instrumentation subdirectory.
+␛[33m2423a863e15b␛[m HEAD@{139}: rebase (pick): Implement global variables. Struct and Pointer initializers are not implemented yet though
+␛[33m3af979135686␛[m HEAD@{140}: rebase (pick): Implement linking of global variable constant references
+␛[33mc1129719df3c␛[m HEAD@{141}: rebase (pick): Add some more interesting test cases for the linker
+␛[33m23ab0f2c31f9␛[m HEAD@{142}: rebase (pick): Oops, didn't handle hex values correctly. :(
+␛[33mc39415b7c1cd␛[m HEAD@{143}: rebase (pick): * Fix the constpoolarray -> c"" printing routines to escape things properly
+␛[33meb2b5e2b34dd␛[m HEAD@{144}: rebase (pick): *** empty log message ***
+␛[33ma28f8e125258␛[m HEAD@{145}: rebase (pick): Minor cleanup
+␛[33m131d908673ef␛[m HEAD@{146}: rebase (pick): *** empty log message ***
+␛[33mc11c83a339c8␛[m HEAD@{147}: rebase (pick): Implement linker. It's 95% working now.
+␛[33m30fa72c1feb8␛[m HEAD@{148}: rebase (pick): More interesting testcase
+␛[33m5a055ed280fd␛[m HEAD@{149}: rebase (pick): Forward operands into implicit uses as well as explicit ones.
+␛[33meab25baceb5b␛[m HEAD@{150}: rebase (pick): External methods shouldn't have argument lists
+␛[33mf2bd12a6d988␛[m HEAD@{151}: rebase (pick): Update comment, remove misleading method
+␛[33m67bb9adc5a0f␛[m HEAD@{152}: rebase (pick): Initializers are not const even if the GV is.
+␛[33mc3d3c0630d9d␛[m HEAD@{153}: rebase (pick): Add a new -d argument to dump the internal rep as assembly.
+␛[33ma7b34ac799ce␛[m HEAD@{154}: rebase (pick): Cast NULL when requested.
+␛[33m731d883c3187␛[m HEAD@{155}: rebase (pick): Added getEntryNode() and getExitNode() functions.
+␛[33m0003ef936aab␛[m HEAD@{156}: rebase (pick): Insert code to trace values at basic block and method exits.
+␛[33ma4927eee849c␛[m HEAD@{157}: rebase (pick): Insert code to trace values at basic block and method exits.
+␛[33m59a501e47f06␛[m HEAD@{158}: rebase (pick): Added routine to create a char array for a string.
+␛[33mf3328d15f543␛[m HEAD@{159}: rebase (pick): Added routine to create a char array for a string.
+␛[33m1b48aa670b0f␛[m HEAD@{160}: rebase (pick): Enable most tests.
+␛[33mb578289a8fa8␛[m HEAD@{161}: rebase (pick): Added a string global variable.
+␛[33m86d5a822efcc␛[m HEAD@{162}: rebase (pick): Two bug fixes that were suppressing some "load-constant-into-register" instrs.
+␛[33mae10fbb5bb27␛[m HEAD@{163}: rebase (pick): Move the burg file to here. Add .in suffix to indicate that it gets
+␛[33m42fcb2d89630␛[m HEAD@{164}: rebase (pick): Make the sparc.burg file be a little more flexible and rubust in the fact of
+␛[33me5eb3fe6f018␛[m HEAD@{165}: rebase (pick): Use the instruction.def file to remain up to date with future instruction
+␛[33ma95ca89e8976␛[m HEAD@{166}: rebase (pick): New file to define instructions...
+␛[33m1a9806113e30␛[m HEAD@{167}: rebase (pick): Burg files should come out of the Debug Directory for temporary files
+␛[33ma1012b17f9a7␛[m HEAD@{168}: rebase (pick): New module linking functionality prototype
+␛[33m5726d1d2ecd4␛[m HEAD@{169}: rebase (pick): Check in makefile
+␛[33mbfc372b3a5a3␛[m HEAD@{170}: rebase (pick): Fixed tags target so it only happens at root level.
+␛[33mad26264a523c␛[m HEAD@{171}: rebase (pick): Add C source for testmisc.ll
+␛[33m9c5a5f970837␛[m HEAD@{172}: rebase (pick): Dang, I screwed up the merge. This should be better
+␛[33mdb6e9ecc453f␛[m HEAD@{173}: rebase (pick): New testcase for testing constant pointers to globals
+␛[33m5eff5faafba2␛[m HEAD@{174}: rebase (pick): Test files for linker
+␛[33m77a7c277d54d␛[m HEAD@{175}: rebase (pick): MethodTypes take an explicit isVarArg argument
+␛[33m19293514b699␛[m HEAD@{176}: rebase (pick): Fix comment flyer
+␛[33m684125529570␛[m HEAD@{177}: rebase (pick): Add new linker
+␛[33mcff52fd4a48a␛[m HEAD@{178}: rebase (pick): Build the new linker
+␛[33mcba92a5489f2␛[m HEAD@{179}: rebase (pick): Use null keyword instead of kludge
+␛[33m42c3881f4c41␛[m HEAD@{180}: rebase (pick): Add more function call and prototype specific tests
+␛[33mc82370afa049␛[m HEAD@{181}: rebase (pick): Compile the transforms directory
+␛[33m6dad439c635a␛[m HEAD@{182}: rebase (pick): Start of a linker
+␛[33m71585a57f2b0␛[m HEAD@{183}: rebase (pick): Implement the invoke instruction
+␛[33m4aac971feb66␛[m HEAD@{184}: rebase (pick): * Fix a nefarious bugs: TypesEqual was wrong for varargs methods
+␛[33m81374f6531a5␛[m HEAD@{185}: rebase (pick): Convert a runtime check into an assertion
+␛[33mfc856307fe9a␛[m HEAD@{186}: rebase (pick): * Add support for Module specific constants
+␛[33m5119ee94dd54␛[m HEAD@{187}: rebase (pick): Add new TerminatorInst ctor for invoke
+␛[33m97aceab30ca0␛[m HEAD@{188}: rebase (pick): * Fix TODO
+␛[33mfdd33fff63c6␛[m HEAD@{189}: rebase (pick): Fix broken #endif
+␛[33m6eab48b3c68d␛[m HEAD@{190}: rebase (pick): * Add #include
+␛[33md64929f66211␛[m HEAD@{191}: rebase (pick): Add StringList support
+␛[33md5f1339c1461␛[m HEAD@{192}: rebase (pick): Support the invoke instruction
+␛[33m362b89b2697e␛[m HEAD@{193}: rebase (pick): Support indirect calls
+␛[33m250990a3ef85␛[m HEAD@{194}: rebase (pick): not is a keyword in ansi C++, avoid it
+␛[33mcad98049b01e␛[m HEAD@{195}: rebase (pick): * Fix privacy issues on RegToRefVecMap
+␛[33m6d8a50fb7185␛[m HEAD@{196}: rebase (pick): * Use new style casts more
+␛[33md5ef68f42b47␛[m HEAD@{197}: rebase (pick): * Add real support for global variable addresses initializing constants
+␛[33m5b89a0710636␛[m HEAD@{198}: rebase (pick): * Support writing GlobalVariables with info comments by them
+␛[33m38600d48ce25␛[m HEAD@{199}: rebase (pick): * Add support for forward references of global variable addresses
+␛[33m30567de7ef54␛[m HEAD@{200}: rebase (pick): Add operator< to ValID's so that they can be put in map's
+␛[33mc4253f651f13␛[m HEAD@{201}: rebase (pick): Remove exception specification
+␛[33me46a527bd890␛[m HEAD@{202}: rebase (pick): Support the new Invoke instruction
+␛[33mdbf3974c7876␛[m HEAD@{203}: rebase (pick): Support pointers to globals happily
+␛[33mf72067424d95␛[m HEAD@{204}: rebase (pick): Fix code to make GCC 2.96 happy
+␛[33mec668ae234aa␛[m HEAD@{205}: rebase (pick): * Add support for Invoke instructions
+␛[33mb92a0735743c␛[m HEAD@{206}: rebase (pick): Fix filename in comment
+␛[33meac143eefddc␛[m HEAD@{207}: rebase (pick): Better linux support. This file still sucks
+␛[33m98503c7ebc77␛[m HEAD@{208}: rebase (pick): Fix broken #endif
+␛[33mca3d924e3846␛[m HEAD@{209}: rebase (pick): not is a keyword in Ansi C++. Avoid it
+␛[33mc168bc53e09e␛[m HEAD@{210}: rebase (pick): Clean up initializers for GCC 2.96
+␛[33mb54fa1a20171␛[m HEAD@{211}: rebase (pick): Remove exception specification. Only slows code down.
+␛[33med95b6657e6b␛[m HEAD@{212}: rebase (pick): Changes to compile with GCC 2.96
+␛[33mc22edf4bc5a2␛[m HEAD@{213}: rebase (pick): Add comment indicating semantics of indirect calls
+␛[33m4dcafac17dcb␛[m HEAD@{214}: rebase (pick): New ctor for invoke inst
+␛[33ma8a651345904␛[m HEAD@{215}: rebase (pick): Add support for indirect calls
+␛[33maf0d7630a30d␛[m HEAD@{216}: rebase (pick): Add some casts to make GCC 2.96 happy.
+␛[33m868db5e40c09␛[m HEAD@{217}: rebase (pick): Add use_back() methods
+␛[33m08696c9b3a19␛[m HEAD@{218}: rebase (pick): Add classof implementations for User
+␛[33m3776f284eb1a␛[m HEAD@{219}: rebase (pick): Expose typedefs
+␛[33md5660029e7f9␛[m HEAD@{220}: rebase (pick): Add support for module local constants
+␛[33m8f28f49eecf5␛[m HEAD@{221}: rebase (pick): Add new opcode for Invoke instruction
+␛[33mc6c0d280af0b␛[m HEAD@{222}: rebase (pick): Minor changes, add new ctor for invoke instruction
+␛[33mf230dca276c8␛[m HEAD@{223}: rebase (pick): Add assertions
+␛[33mc4ea40ffae4f␛[m HEAD@{224}: rebase (pick): * Minor Formatting changes.
+␛[33me4f89d5176af␛[m HEAD@{225}: rebase (pick): * Add destroyConstant stuff to handle module local constants
+␛[33m0a73f5e2e880␛[m HEAD@{226}: rebase (pick): Update todo's
+␛[33mb66fb116fe18␛[m HEAD@{227}: rebase (pick): Each tools should not make tags
+␛[33m969240424993␛[m HEAD@{228}: rebase (pick): --corrected coalescing test: coalsed only if two are of the same reg class
+␛[33m54622d353dc1␛[m HEAD@{229}: rebase (pick): added support for implict operands in machine instruction
+␛[33maf225afe483a␛[m HEAD@{230}: rebase (pick): --added support for implicit operands in machine instructions
+␛[33m4c1eeb2f0207␛[m HEAD@{231}: rebase (pick): Delete *.s on clean.
+␛[33me0e2c0de0d59␛[m HEAD@{232}: rebase (pick): Record implicitRefs for each machine instruction instead of
+␛[33mc7344856e2e2␛[m HEAD@{233}: rebase (pick): Add graph edges due to implicit refs in each machine instruction.
+␛[33mda6e725984b0␛[m HEAD@{234}: rebase (pick): Added a rule for building TAGS.
+␛[33m84249865be76␛[m HEAD@{235}: rebase (pick): Repeat some libs due to circular dependences between Sparc and other
+␛[33mb41937df9bac␛[m HEAD@{236}: rebase (pick): Don't insert useful instructions in delay slot of a RETURN.
+␛[33m8ec3840fd358␛[m HEAD@{237}: rebase (pick): Insert code to load constants used as Call or Return arguments.
+␛[33mdfb65425ee14␛[m HEAD@{238}: rebase (pick): Machine-independent code generation routines used in instruction
+␛[33me8a1ea03539a␛[m HEAD@{239}: rebase (pick): Moved code generation support routines to InstrSelectionSupport.{h,cpp}.
+␛[33m920028cc0b2f␛[m HEAD@{240}: rebase (pick): Moved code generation support routines to InstrSelectionSupport.cpp.
+␛[33m362badd47ffe␛[m HEAD@{241}: rebase (pick): Moved first function to "simpleadd.ll".
+␛[33me3a87d5e89a0␛[m HEAD@{242}: rebase (pick): testmemory and sumarray now work with instruction selection.
+␛[33ma08813e66ef9␛[m HEAD@{243}: rebase (pick): --removed %g regs being allocated - fix later
+␛[33m576355e82463␛[m HEAD@{244}: rebase (pick): Add hack to get rid of malloc & free instructions for code generation
+␛[33m5566f9c03615␛[m HEAD@{245}: rebase (pick): Add comment
+␛[33m704887cc1858␛[m HEAD@{246}: rebase (pick): Support multiple global's definitions
+␛[33m97e5c873483d␛[m HEAD@{247}: rebase (pick): Factor parentness out of Module & GlobalVariable into GlobalValue
+␛[33m370c4a28a876␛[m HEAD@{248}: rebase (pick): Rename getNullPointer to getNull
+␛[33mddfe3ae972ff␛[m HEAD@{249}: rebase (pick): Rename getNullPointer to getNull
+␛[33m7b0ee1e797ab␛[m HEAD@{250}: rebase (pick): Allow duplicate constant values as long as they are compatible.
+␛[33ma13bc1844828␛[m HEAD@{251}: rebase (pick): Share ConstPoolPointer elements correctly
+␛[33mbd8752038e30␛[m HEAD@{252}: rebase (pick): Fix broken testcase
+␛[33m398a1a5573f9␛[m HEAD@{253}: rebase (pick): Add check to make sure that we dont reference MEthodType's directly
+␛[33mbdb349a55426␛[m HEAD@{254}: rebase (pick): * Both Method & GlobalVariable now subclass GlobalValue
+␛[33m5c22b0d643af␛[m HEAD@{255}: rebase (pick): Adjust test cases to match the fact that methods are now explicit pointer values, not explicit
+␛[33m1f92e9fc5d90␛[m HEAD@{256}: rebase (pick): First try at a horrible global value reference wrapper
+␛[33mebf7f8fa07e7␛[m HEAD@{257}: rebase (pick): Clean up parser, fix a bug that prevented this from working:
+␛[33meedd6c7c8622␛[m HEAD@{258}: rebase (pick): * Add support for null as a constant
+␛[33m550de7f1b919␛[m HEAD@{259}: rebase (pick): Modify testcases for new LLVM const syntax
+␛[33mdfe6c7e0aff1␛[m HEAD@{260}: rebase (pick): Commit more code over to new cast style
+␛[33m8d5994a86223␛[m HEAD@{261}: rebase (pick): Convert more code to use new style casts
+␛[33m22c53dc308b0␛[m HEAD@{262}: rebase (pick): Add more support for new style casts
+␛[33me876f00ebb60␛[m HEAD@{263}: rebase (pick): Add support for new style casts
+␛[33m0b735821091f␛[m HEAD@{264}: rebase (pick): Add support for newer cleaner isa, cast, dyn_cast
+␛[33m8f546a6b1eb9␛[m HEAD@{265}: rebase (pick): Update comments
+␛[33m154b8c0b0bdb␛[m HEAD@{266}: rebase (pick): Pull predecessor and successor iterators out of the CFG*.h files, and plop them into
+␛[33m96bfa8db5614␛[m HEAD@{267}: rebase (pick): Pull predecessor and successor iterators out of the CFG*.h files, and plop them into
+␛[33m0c5cd66015ba␛[m HEAD@{268}: rebase (pick): Comment out a paragraph that refers to a file that no longer exists
+␛[33mbf9adf15ad50␛[m HEAD@{269}: rebase (pick): Fix emission of return instructions
+␛[33maf1ab310689d␛[m HEAD@{270}: rebase (pick): Add path to as so it doesn't find llvm as if that path is set.
+␛[33m554b4bc20205␛[m HEAD@{271}: rebase (pick): Exclude a couple of tests that the regalloc stuff doesn't handle yet
+␛[33m2d6c6b32a60e␛[m HEAD@{272}: rebase (pick): Add different "cast constant value" for several possible types.
+␛[33m5a0bdbf41700␛[m HEAD@{273}: rebase (pick): Add vector `implicitUses' to class MachineCodeForVMInstr to hold values
+␛[33m69e68114634e␛[m HEAD@{274}: rebase (pick): Several fixes:
+␛[33mecfd19aa7a65␛[m HEAD@{275}: rebase (pick): removing phy regaloc - incorrect file
+␛[33mc9899c19a917␛[m HEAD@{276}: rebase (pick): Change latency of setuw and setsw to 2 cycles.
+␛[33m8e03b2d97f34␛[m HEAD@{277}: rebase (pick): Change ! ( ...== ...) to !=.
+␛[33maa06d6438043␛[m HEAD@{278}: rebase (pick): Improved dump for disp type operand.
+␛[33md09bbd3e62ee␛[m HEAD@{279}: rebase (pick): Bug fixes:
+␛[33m4542845ffac4␛[m HEAD@{280}: rebase (pick): Minor changes for bug fixes in SchedGraph.cpp.
+␛[33mf2d34339b43a␛[m HEAD@{281}: rebase (pick): Two bug fixes:
+␛[33mdadedae23021␛[m HEAD@{282}: rebase (pick): *** empty log message ***
+␛[33me30f6b836af1␛[m HEAD@{283}: rebase (pick): no major change.
+␛[33m17745bb05c7a␛[m HEAD@{284}: rebase (pick): added suggesting color support
+␛[33m0c5afc6b26f2␛[m HEAD@{285}: rebase (pick): added suggesting color suppor
+␛[33mbdaab1203288␛[m HEAD@{286}: rebase (pick): added support for suggesting colors
+␛[33m3061d7a1e42b␛[m HEAD@{287}: rebase (pick): --added suggesting colors; call/ret arg handling
+␛[33mf3d3eee7e06a␛[m HEAD@{288}: rebase (pick): Add a test for the new null keyword
+␛[33m8e9b70834fa4␛[m HEAD@{289}: rebase (pick): Implement constant pointers, and null specifically in the parser, bytecode writer, and
+␛[33md20cd6b4422b␛[m HEAD@{290}: rebase (pick): Implement a constant pointer value
+␛[33m91bf6d53e2e8␛[m HEAD@{291}: rebase (pick): Pull iterators out of CFG.h and genericize them with GraphTraits
+␛[33m1f5ff53527ab␛[m HEAD@{292}: rebase (pick): File #include file
+␛[33m60f364cc5b13␛[m HEAD@{293}: rebase (pick): Pull iterators out of CFG.h and CFGdecls and put them in Support directory
+␛[33mab4adf7cba15␛[m HEAD@{294}: rebase (pick): * Properly escape function names
+␛[33mb329ccfca12b␛[m HEAD@{295}: rebase (pick): Check in bug fix for vadve
+␛[33m3eaa426db4d4␛[m HEAD@{296}: rebase (pick): Add commands to assemble and compile a .ll file
+␛[33m0fd9a3dcc702␛[m HEAD@{297}: rebase (pick): Initial support for construction of a call graph
+␛[33mb3a3ecaf05f7␛[m HEAD@{298}: rebase (pick): Add support to print a call graph, and also add support for module level interprocedural analyses
+␛[33m464bdb4b73aa␛[m HEAD@{299}: rebase (pick): Adding the tool to the path doesn't break anything anymore
+␛[33mf1f7f171a7a5␛[m HEAD@{300}: rebase (pick): Make error report a little more useful
+␛[33m58d981ac2a15␛[m HEAD@{301}: rebase (pick): ADCE is broken but at least we know why
+␛[33mdae33afb6ab1␛[m HEAD@{302}: rebase (pick): print out value's by pointer
+␛[33mcb586b4aa067␛[m HEAD@{303}: rebase (pick): Add capability to print out call graph
+␛[33m24c1bbab59ca␛[m HEAD@{304}: rebase (pick): Global variables/complex constants have been resolved!
+␛[33m4d13ee0a9344␛[m HEAD@{305}: rebase (pick): -- fixed a ret val bug
+␛[33m19f2d28d3fb2␛[m HEAD@{306}: rebase (pick): -- removed debugging messages
+␛[33md23e458745cb␛[m HEAD@{307}: rebase (pick): -fixed return value bug.
+␛[33mb53ab66b2055␛[m HEAD@{308}: rebase (pick): Add proper support to send output to the right place
+␛[33m1da35ac9ce16␛[m HEAD@{309}: rebase (pick): Print .def files as well as other files
+␛[33m1a7c20d822d2␛[m HEAD@{310}: rebase (pick): Change debug info from #define to command line option
+␛[33mbdd630363635␛[m HEAD@{311}: rebase (pick): Change debug info from #define to command line option
+␛[33md27bcdc4d564␛[m HEAD@{312}: rebase (pick): * REMOVE extraneous debug info if DEBUG_RA is not set
+␛[33mb58b0442c078␛[m HEAD@{313}: rebase (pick): Seperate instruction definitions into new SparcInstr.def file
+␛[33m84ba33c8b41a␛[m HEAD@{314}: rebase (pick): Okay, make the member function work.
+␛[33mc14992951e06␛[m HEAD@{315}: rebase (pick): Remove global debug output fns that have been superceded by a member func
+␛[33m78a5c492e944␛[m HEAD@{316}: rebase (pick): Remove debugging output stuff
+␛[33m3f14f79d64e6␛[m HEAD@{317}: rebase (pick): Emit assembly language from the target...
+␛[33m5a780fe743b5␛[m HEAD@{318}: rebase (pick): Add emitAssembly Method
+␛[33m6d1bd8d21e41␛[m HEAD@{319}: rebase (pick): Add idea
+␛[33mf821fceb8d6a␛[m HEAD@{320}: rebase (pick): Add EmitAssembly to mf
+␛[33md2ccd8e344fc␛[m HEAD@{321}: rebase (pick): First cut at assembly output
+␛[33m7cd873804115␛[m HEAD@{322}: rebase (pick): Add emitAssemblyMethod to TargetMachine
+␛[33m8749075054d9␛[m HEAD@{323}: rebase (pick): *** empty log message ***
+␛[33mca4aeed4cda6␛[m HEAD@{324}: rebase (pick): --added methods to operand class to set/get registers after register allocation
+␛[33md3262f97ed7a␛[m HEAD@{325}: rebase (pick): -- ruchira
+␛[33m983537f3112b␛[m HEAD@{326}: rebase (pick): -- updated printing
+␛[33mdf8fc0fcada5␛[m HEAD@{327}: rebase (pick): Remove a copy of a bunch of code
+␛[33m5ff0c9da9f43␛[m HEAD@{328}: rebase (pick): C++ gives us auto_ptr's, so we might as well use them. :)
+␛[33m0a6274f4f469␛[m HEAD@{329}: rebase (pick): Fix up code a bit, remove operator<< to Assembly/Writer.h
+␛[33m8ebd15ef9e5b␛[m HEAD@{330}: rebase (pick): Remove extraneous #includes
+␛[33m992e6cf11454␛[m HEAD@{331}: rebase (pick): Move operator << from Value.h to Assembly/Writer.h
+␛[33m05c03e0a4a43␛[m HEAD@{332}: rebase (pick): Remove operator << to Assembly/Writer.h
+␛[33m32354c42e162␛[m HEAD@{333}: rebase (pick): Don't check for null on delete
+␛[33m348cbcb3414c␛[m HEAD@{334}: rebase (pick): Un-neuter makefile
+␛[33mb9015643ae16␛[m HEAD@{335}: rebase (pick): Minor changes.
+␛[33m31eddde1fbe7␛[m HEAD@{336}: rebase (pick): Folded inssel*.ll into select.ll.
+␛[33m93a7445ced49␛[m HEAD@{337}: rebase (pick): Renamed files to match the primary classes they provide.
+␛[33m73a5ca83c073␛[m HEAD@{338}: rebase (pick): Renamed a header file.
+␛[33m116c6caa7247␛[m HEAD@{339}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+␛[33m4fc2bc116a7f␛[m HEAD@{340}: rebase (pick): Allow pointer constants as well as integer and booleans.
+␛[33m4350d1b2f431␛[m HEAD@{341}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+␛[33mc3645e342ca4␛[m HEAD@{342}: rebase (pick): Renamed files to match the main classes they provide.
+␛[33m2221c6a54d56␛[m HEAD@{343}: rebase (pick): Cast unsigned to int! It was causing a nice little bug.
+␛[33m3692872402ab␛[m HEAD@{344}: rebase (pick): Minor changes.
+␛[33mfdf7be61f2e0␛[m HEAD@{345}: rebase (pick): Don't add instructions to subtree for Phi or Call.
+␛[33mc5ec3128e60a␛[m HEAD@{346}: rebase (pick): Format file header.
+␛[33m9bce80700742␛[m HEAD@{347}: rebase (pick): Add new entry/exit edges when removing delay slot nodes from the graph.
+␛[33m0c5c4e8dfb45␛[m HEAD@{348}: rebase (pick): Moved erase edge functions to class SchedGraph.
+␛[33mad74a2f916dd␛[m HEAD@{349}: rebase (pick): Renamed some header files.
+␛[33m6f280562c6f1␛[m HEAD@{350}: rebase (pick): Moved erase-edge functions from SchedGraphNode to SchedGraph.
+␛[33mc20d754ef692␛[m HEAD@{351}: rebase (pick): Moved DebugValue to Value.cpp.
+␛[33ma18896cb69d9␛[m HEAD@{352}: rebase (pick): Added debugging support.
+␛[33mb99a5873a966␛[m HEAD@{353}: rebase (pick): Moved debugging interfaces for class Value to Value.h.
+␛[33mde14aceb2e19␛[m HEAD@{354}: rebase (pick): Minor fixes: renamed target machine files; fold sched info into TargetMachine.
+␛[33m1fabb8f4d05b␛[m HEAD@{355}: rebase (pick): Make class TargetMachine the common interface to all target-dependent
+␛[33m004e1e8c9bd5␛[m HEAD@{356}: rebase (pick): Added debugging support.
+␛[33m5308e6f9d6ca␛[m HEAD@{357}: rebase (pick): Fix testcases to handle new syntax for construction and initializeation
+␛[33m23bc63990bca␛[m HEAD@{358}: rebase (pick): Remove the unsized array constraint
+␛[33m23b021feb086␛[m HEAD@{359}: rebase (pick): Add support for global constants, and for initializers for constants
+␛[33m1f2803d9c6b3␛[m HEAD@{360}: rebase (pick): Add support for global constants, and for initializers for constants
+␛[33me1fed6f079c9␛[m HEAD@{361}: rebase (pick): added a method to get reg num after register allocation
+␛[33mae7bbf4710cc␛[m HEAD@{362}: rebase (pick): modified machine code printing
+␛[33m13af7a7caac6␛[m HEAD@{363}: rebase (pick): -modified machine operand class - took regNum out of union to set regNum after
+␛[33m6bddc120b229␛[m HEAD@{364}: rebase (pick): modified printing of debug messages
+␛[33m313c2a193181␛[m HEAD@{365}: rebase (pick): --added methods for printing
+␛[33mb8916ea9dfc9␛[m HEAD@{366}: rebase (pick): added setRegForValue to MachineOperand class
+␛[33m072b09e468f8␛[m HEAD@{367}: rebase (pick): fixed printing messages
+␛[33m357bf235defd␛[m HEAD@{368}: rebase (pick): -- debug messages dissabled
+␛[33mb3a9794066b2␛[m HEAD@{369}: rebase (pick): added reg alloc support
+␛[33m4ac010f69361␛[m HEAD@{370}: rebase (pick): --reg alloc code added
+␛[33mc7e1696e212a␛[m HEAD@{371}: rebase (pick): -reg alloc code
+␛[33m74fe0add218c␛[m HEAD@{372}: rebase (pick): added register allocation code
+␛[33m1c1d5b77ea72␛[m HEAD@{373}: rebase (pick): Added regalloc
+␛[33m261723120208␛[m HEAD@{374}: rebase (pick): Oops, accidentally checked my debugging makefile
+␛[33mccba943ebd24␛[m HEAD@{375}: rebase (pick): Fix a bug with not removing method level types after compilation
+␛[33m32436a343662␛[m HEAD@{376}: rebase (pick): added RegAlloc Directory to DIRS
+␛[33m1c24930f9da4␛[m HEAD@{377}: rebase (pick): *** empty log message ***
+␛[33mcac3722a15a8␛[m HEAD@{378}: rebase (pick): *** empty log message ***
+␛[33mc6554b4537c1␛[m HEAD@{379}: rebase (pick): Remove invalid testcase
+␛[33m847094903baa␛[m HEAD@{380}: rebase (pick): Remove invalid testcase. Unneccesary anyways
+␛[33md71ff5c79c96␛[m HEAD@{381}: rebase (pick): Add new test cases
+␛[33m7789d9c7f54d␛[m HEAD@{382}: rebase (pick): Add support for loading and storing pointers...
+␛[33ma3aa024f5831␛[m HEAD@{383}: rebase (pick): Fix a bug that caused a crash if a setcc had zero uses.
+␛[33mc70348cb828c␛[m HEAD@{384}: rebase (pick): Add a forward decl, oops.
+␛[33m85c86566e9a5␛[m HEAD@{385}: rebase (pick): Chris seems fond of #include <vector>. Fix these. Also convert use list in
+␛[33m3edb0d2e080e␛[m HEAD@{386}: rebase (pick): Add a comment
+␛[33m5c8a3647ccb6␛[m HEAD@{387}: rebase (pick): Minor reformatting, & protection fixes
+␛[33mec87fa4f8523␛[m HEAD@{388}: rebase (pick): Break scheduling infrastructure out of TargetMachine.cpp into SchedInfo.cpp
+␛[33md589bb98df47␛[m HEAD@{389}: rebase (pick): Split Register specific stuff out from TargetMachine.h to RegInfo.h
+␛[33mec018be202c8␛[m HEAD@{390}: rebase (pick): Split Target/Machine.h into three files:
+␛[33m53bcc4463c09␛[m HEAD@{391}: rebase (pick): Make a new llvm/Target #include directory.
+␛[33maaca226978d7␛[m HEAD@{392}: rebase (pick): Checkin changes to:
+␛[33m9cec2d47b443␛[m HEAD@{393}: rebase (pick): Checkin changes to:
+␛[33m3b15eb471b31␛[m HEAD@{394}: rebase (pick): Move files to new sparc directory
+␛[33m11954336afe2␛[m HEAD@{395}: rebase (pick): Move the sparc target to a new lib/Target directory
+␛[33ma8d3715d2038␛[m HEAD@{396}: rebase (pick): Move files.
+␛[33m82cb584aec3c␛[m HEAD@{397}: rebase (pick): Move the contents of the CodeGen/TargetMachine/Sparc directory to Target/Sparc
+␛[33m1799226a9df7␛[m HEAD@{398}: rebase (pick): This checkin represents some cleanup of the backend, implementing the following things:
+␛[33m2153a7e280f6␛[m HEAD@{399}: rebase (pick): This checkin represents some cleanup of the backend, implementing the following things:
+␛[33m9936a71b49ba␛[m HEAD@{400}: rebase (pick): Updates to use local header files.
+␛[33mddef6185b427␛[m HEAD@{401}: rebase (pick): Export the instruction forest support from the analysis library
+␛[33m44e4e80c2911␛[m HEAD@{402}: rebase (pick): Initial instruction tree support for the analysis library
+␛[33m001ff12fbe1c␛[m HEAD@{403}: rebase (pick): Generic k-way tree support
+␛[33m015b075f7f69␛[m HEAD@{404}: rebase (pick): More cleanups, preparing to revamp InstrForest to, among other things,
+␛[33md6c5ea5c2392␛[m HEAD@{405}: rebase (pick): * Clean up InstrForest
+␛[33m8f70795fa947␛[m HEAD@{406}: rebase (pick): Eliminate 'BasicNode' from InstrForest.
+␛[33m02e210b78442␛[m HEAD@{407}: rebase (pick): Eliminate MainTreeNode function
+␛[33mbacc3815ee3a␛[m HEAD@{408}: rebase (pick): Remove irrelevant gross K&R Cisms
+␛[33m99dec15bddc1␛[m HEAD@{409}: rebase (pick): Handle subtract in expression classifier
+␛[33m9c9d9777ee76␛[m HEAD@{410}: rebase (pick): Disable destructors on constants
+␛[33m58b30135c56a␛[m HEAD@{411}: rebase (pick): Use the correct style casts
+␛[33m6fb05a7fb6f1␛[m HEAD@{412}: rebase (pick): Use correct style casts
+␛[33mf6d78c00b28d␛[m HEAD@{413}: rebase (pick): Use correct style casts
+␛[33mbd9287aa5602␛[m HEAD@{414}: rebase (pick): Use type checking predicates
+␛[33mb760399acaf2␛[m HEAD@{415}: rebase (pick): Use correct casts
+␛[33m86f6acb766bb␛[m HEAD@{416}: rebase (pick): Use predicate for Value type test
+␛[33mb1223a7dc00c␛[m HEAD@{417}: rebase (pick): Use predicate for Value type test
+␛[33m5dbd964b9fbc␛[m HEAD@{418}: rebase (pick): ModuleTyID doesn't exist anyymore
+␛[33mc583d68d95f8␛[m HEAD@{419}: rebase (pick): getMethodType is now just getType
+␛[33m862b2212c267␛[m HEAD@{420}: rebase (pick): Add support for printing globals
+␛[33m9815c0143466␛[m HEAD@{421}: rebase (pick): Update to use correct type cast
+␛[33m4ebfeafd5ae2␛[m HEAD@{422}: rebase (pick): Add support for global variables
+␛[33m7309e89eeead␛[m HEAD@{423}: rebase (pick): * Add capability of printing out a global variable
+␛[33m332d403bc73d␛[m HEAD@{424}: rebase (pick): * Method::getType should return type cast as MethodType, eliminate getMethodType
+␛[33m09b1c8b53b5b␛[m HEAD@{425}: rebase (pick): Update assertion to allow extra case
+␛[33mc9f650f82da6␛[m HEAD@{426}: rebase (pick): Fix a bug I introduced (assertion failed: Unknown operand type), and convert to predicate style for type checks
+␛[33mca665a4f7301␛[m HEAD@{427}: rebase (pick): Implement global variable support
+␛[33m78c27fc8588b␛[m HEAD@{428}: rebase (pick): Add support for external methods
+␛[33m3b4968db64d9␛[m HEAD@{429}: rebase (pick): Genericize support for calling functions a bit
+␛[33mf2292a6f5bef␛[m HEAD@{430}: rebase (pick): Add support for tool specified linker options
+␛[33me7d26918d539␛[m HEAD@{431}: rebase (pick): Remove the definitions of 3 global functions that don't belong in the core
+␛[33m3268cb00c3aa␛[m HEAD@{432}: rebase (pick): Implement the subset of the GetConstantValueAsSignedInt function that is needed, locally. Remove the two support functions to inline their contents.
+␛[33m5ce25378872d␛[m HEAD@{433}: rebase (pick): Implement the subset of the GetConstantValueAsSignedInt function that is needed, locally.
+␛[33m7f1dfe6c75ba␛[m HEAD@{434}: rebase (pick): Remove 3 gross global functions that don't belong here
+␛[33mbcfd7d3b4a2f␛[m HEAD@{435}: rebase (pick): Rename contype to subtype
+␛[33m925282156193␛[m HEAD@{436}: rebase (pick): Make ADCE more robust, it still has problems, but it's getting closer
+␛[33ma8aa73f44e44␛[m HEAD@{437}: rebase (pick): Fix problems with freeing memory twice
+␛[33m3e58e695c052␛[m HEAD@{438}: rebase (pick): Rename file to be consistent with header name
+␛[33m45093beca645␛[m HEAD@{439}: rebase (pick): Rerun backend tests if as or llc is changed
+␛[33m920978127ffb␛[m HEAD@{440}: rebase (pick): iFix dependence order
+␛[33m0dda5dffe9e1␛[m HEAD@{441}: rebase (pick): Clean up Type class by removing mutable ConstRules member and use annotations insead
+␛[33m8926543a23ba␛[m HEAD@{442}: rebase (pick): Clean up ConstRules stuff to use annotations instead of a mutable member in Type
+␛[33m0554a9254254␛[m HEAD@{443}: rebase (pick): Convert ConstRules to use annotations to clean it up.
+␛[33mae70148c0e33␛[m HEAD@{444}: rebase (pick): Fix automatic dependence on static libs
+␛[33m57a4461c8737␛[m HEAD@{445}: rebase (pick): Handle cast float-to-float or cast double-to-double.
+␛[33me26d17b941c6␛[m HEAD@{446}: rebase (pick): Fix build breakage. :(
+␛[33m468369dd37c3␛[m HEAD@{447}: rebase (pick): I really don't like it when people break the build.
+␛[33m093db3f2c28b␛[m HEAD@{448}: rebase (pick): Remove extraneous space
+␛[33md7fa14961741␛[m HEAD@{449}: rebase (pick): Remove extra #include
+␛[33m13c90b0c405c␛[m HEAD@{450}: rebase (pick): *** empty log message ***
+␛[33mad0e744b8800␛[m HEAD@{451}: rebase (pick): *** empty log message ***
+␛[33m479d6ea91cea␛[m HEAD@{452}: rebase (pick): Committed for compliation. Not yet final.
+␛[33m3e3b370cfca9␛[m HEAD@{453}: rebase (pick): --Ruchira
+␛[33m215ca905feb5␛[m HEAD@{454}: rebase (pick): New testcase to deal with lists
+␛[33m91c3618d9fba␛[m HEAD@{455}: rebase (pick): New file for supporting abstract types
+␛[33md0201e668537␛[m HEAD@{456}: rebase (pick): Make use of the new TOOLNAME/USEDLIBS options provided in Makefile.common
+␛[33medadb7525ef9␛[m HEAD@{457}: rebase (pick): Executables all live in a nice centralized location now
+␛[33ma461b8412da2␛[m HEAD@{458}: rebase (pick): Executables have moved into centralized location
+␛[33mf02709b9d7a9␛[m HEAD@{459}: rebase (pick): Support TOOLNAME and USEDLIBS options for easier tool building
+␛[33me41581d43385␛[m HEAD@{460}: rebase (pick): Remove old old file
+␛[33mcb93b76e7fdc␛[m HEAD@{461}: rebase (pick): Convert llc driver to standard tool format
+␛[33mcb8ea37f651a␛[m HEAD@{462}: rebase (pick): Provide a way to change the incoming value for a phi node
+␛[33m21daac648d0a␛[m HEAD@{463}: rebase (pick): Add llc path to setup
+␛[33ma3f8c0135396␛[m HEAD@{464}: rebase (pick): Uhm... that was really bad
+␛[33ma428778af63a␛[m HEAD@{465}: rebase (pick): Clean up driver
+␛[33m545e4d0d6342␛[m HEAD@{466}: rebase (pick): Make makefile not depend on where stuff is installed!!!!
+␛[33m63fb58422942␛[m HEAD@{467}: rebase (pick): Updates to work with new lack of constant pool
+␛[33md08a74d2397c␛[m HEAD@{468}: rebase (pick): Remove unneeded #includes
+␛[33m17ba4b1a7377␛[m HEAD@{469}: rebase (pick): Remove unnecesary #include add dump calls pulled out of .h file
+␛[33m4baa9c258dc7␛[m HEAD@{470}: rebase (pick): * Remove lots of #includes
+␛[33m5fbff64a9093␛[m HEAD@{471}: rebase (pick): * Remove lots of unnecesary #includes
+␛[33mfa24fc193248␛[m HEAD@{472}: rebase (pick): * Remove lots of annoying extra #includes
+␛[33m4a1115871ab1␛[m HEAD@{473}: rebase (pick): * Add tag so emacs knows it's a c++ file
+␛[33maa1f51a47db4␛[m HEAD@{474}: rebase (pick): Add tags so emacs knows these are C++ files
+␛[33m66cdfde08ddd␛[m HEAD@{475}: rebase (pick): Remove extra space
+␛[33mdf7b57cb2016␛[m HEAD@{476}: rebase (pick): Remove ReversePostOrderTraversal declaration
+␛[33me182a70686df␛[m HEAD@{477}: rebase (pick): * Don't predefine ReversePostOrderTraversal because it adds a dependence on vector
+␛[33ma7b751de9148␛[m HEAD@{478}: rebase (pick): Check opaque, abstract, and recursive type handling
+␛[33mf65fc4c4b0ca␛[m HEAD@{479}: rebase (pick): NEw file
+␛[33mf5797eee291e␛[m HEAD@{480}: rebase (pick): Moved functionality into the other constant pool stuff
+␛[33mc317aff403de␛[m HEAD@{481}: rebase (pick): Follow the golden rule of the coding standards guide: Make the code look
+␛[33m228b2301a5b8␛[m HEAD@{482}: rebase (pick): The header file for a translation unit should always be included first
+␛[33mec28d6b33de6␛[m HEAD@{483}: rebase (pick): A file should always include it's private header file *FIRST* see the
+␛[33ma4fd66e4bb44␛[m HEAD@{484}: rebase (pick): Constant pool is eliminated
+␛[33m895e8966aaf7␛[m HEAD@{485}: rebase (pick): Add support for iteration through type graphs
+␛[33m1bc1a1e55811␛[m HEAD@{486}: rebase (pick): Remove support for const pool merging, which is obsolete now.
+␛[33m1f68aecd491b␛[m HEAD@{487}: rebase (pick): Annotations are now const
+␛[33maa592d53a869␛[m HEAD@{488}: rebase (pick): Build lli first
+␛[33ma7352c105c5a␛[m HEAD@{489}: rebase (pick): Symboltables are sorted in the bytecode, so no problems here!
+␛[33m5fdc17bb41c2␛[m HEAD@{490}: rebase (pick): Cleanup
+␛[33m98cf8e526cfc␛[m HEAD@{491}: rebase (pick): Support abstract types
+␛[33me64122141c47␛[m HEAD@{492}: rebase (pick): Support a abstract, opaque, and recursive types
+␛[33m299db7ad37f6␛[m HEAD@{493}: rebase (pick): Types and constnats are wierd objects in the symtabs
+␛[33m391ecb41103e␛[m HEAD@{494}: rebase (pick): Modules must have a valid, nonnull type. Make them void
+␛[33m186d4233d066␛[m HEAD@{495}: rebase (pick): Support new setName interface
+␛[33m7339777dc091␛[m HEAD@{496}: rebase (pick): * Support new setname interface
+␛[33mba310ef38dcf␛[m HEAD@{497}: rebase (pick): * Cnstants are now global objects
+␛[33m05ef1117f8d2␛[m HEAD@{498}: rebase (pick): Support new setName itf
+␛[33m3d922776af3d␛[m HEAD@{499}: rebase (pick): Annotations are const objects now
+␛[33m3ad5e85b0e7c␛[m HEAD@{500}: rebase (pick): Types and constants are wierd things in symbol tables now
+␛[33me95eeb238191␛[m HEAD@{501}: rebase (pick): * Eliminate reference to ConstantPool class
+␛[33m69013e51442c␛[m HEAD@{502}: rebase (pick): Constant pool is dead
+␛[33m6aabf9bb8d09␛[m HEAD@{503}: rebase (pick): Constants are now global unique objects
+␛[33m5eccfe8f4744␛[m HEAD@{504}: rebase (pick): * Eliminate constant pool dependancies:
+␛[33m116bd1f60c7d␛[m HEAD@{505}: rebase (pick): * Supoprt global constants
+␛[33m719ec15e3bca␛[m HEAD@{506}: rebase (pick): * Support global constants
+␛[33m3e22e6fbc35c␛[m HEAD@{507}: rebase (pick): annotations are now const
+␛[33m94469c594e8f␛[m HEAD@{508}: rebase (pick): * Emit bytecode using a deque instead of a vector to be faster
+␛[33mcd31dfffe14a␛[m HEAD@{509}: rebase (pick): * Remove support for internal constant pool
+␛[33m0ccb4914c583␛[m HEAD@{510}: rebase (pick): * Assembly writer is not a module analyzer anymore
+␛[33m81be60efae5b␛[m HEAD@{511}: rebase (pick): * Add support for forward referencing types
+␛[33m92f9faa8cd41␛[m HEAD@{512}: rebase (pick): Add support for forward referencing types
+␛[33m7cb39bcc9b11␛[m HEAD@{513}: rebase (pick): Add support for an opaque type
+␛[33m0cc953a4eb36␛[m HEAD@{514}: rebase (pick): Remove #include of nonexistant header file
+␛[33me659434201e7␛[m HEAD@{515}: rebase (pick): * Slot calc is now simpler and not based on module analyzer.
+␛[33md9953427123b␛[m HEAD@{516}: rebase (pick): Module analyzer no longer has to iterate over constant pool
+␛[33m59b2b4978c66␛[m HEAD@{517}: rebase (pick): Simplify code by eliminating need to hang onto constant pool references
+␛[33mca915a915738␛[m HEAD@{518}: rebase (pick): * Fixed mapped_iterator to actually work with functors
+␛[33mdb2d5ad6fc13␛[m HEAD@{519}: rebase (pick): Constant pools no longer exist
+␛[33me6503b4355e7␛[m HEAD@{520}: rebase (pick): Eliminate DoConstantPoolMerging. ConstantPools no longer exist
+␛[33m8e819e87f9aa␛[m HEAD@{521}: rebase (pick): You no longer have to delete constants! They are located in a global
+␛[33m9e1456843e33␛[m HEAD@{522}: rebase (pick): Annotations are now passed around as const objects
+␛[33m37781e4265d3␛[m HEAD@{523}: rebase (pick): Use a deque instead of a vector for greater efficiency writing bytecode
+␛[33m68b52d48b8d2␛[m HEAD@{524}: rebase (pick): Clean stuff up.
+␛[33mef8df94e3aba␛[m HEAD@{525}: rebase (pick): Simplify SlotCalculator. SlotCalculator is now not a ModuleAnalyzer
+␛[33m220b450fb4a8␛[m HEAD@{526}: rebase (pick): Simplify analyzer
+␛[33m435cda780cfc␛[m HEAD@{527}: rebase (pick): * Fix long standing problems that would affect inlining. How could this have worked?
+␛[33m0cb567d4d189␛[m HEAD@{528}: rebase (pick): Add assertion to check for
+␛[33me0ab1c69297f␛[m HEAD@{529}: rebase (pick): * Values are AbstactTypeUsers to support abstract types
+␛[33m16c83b3c1356␛[m HEAD@{530}: rebase (pick): Remove extra whitespace at EOL
+␛[33ma2e45cbc6285␛[m HEAD@{531}: rebase (pick): * Add support for Opaque & Abstract types.
+␛[33m875576a6650b␛[m HEAD@{532}: rebase (pick): Support abstract types by keeping on the use list of the abstract type.
+␛[33m70bc7b10091b␛[m HEAD@{533}: rebase (pick): SymTabValues no longer hold constant pools
+␛[33mc3d4689a42cb␛[m HEAD@{534}: rebase (pick): SymTabValue no longer includes ValueHolder for Module. Include it ourself
+␛[33maefcbb9a7f94␛[m HEAD@{535}: rebase (pick): * Support new setName interface
+␛[33m22059fea78a8␛[m HEAD@{536}: rebase (pick): Support new setName interface
+␛[33m30dd0bdb5f35␛[m HEAD@{537}: rebase (pick): * Add new DerivedType base class that goes between Type and the derived types
+␛[33mfb9e4e1fcdc4␛[m HEAD@{538}: rebase (pick): Implement support for globally unique constants. Constants no longer live
+␛[33m924247d31d99␛[m HEAD@{539}: rebase (pick): Add support for walking type graphs
+␛[33mfa3aa419ab9f␛[m HEAD@{540}: rebase (pick): Changing setName semantics
+␛[33m38d0897ea620␛[m HEAD@{541}: rebase (pick): Make annotations operations const with a mutable annotation list so that
+␛[33m59216be202de␛[m HEAD@{542}: rebase (pick): Fixed the "output constant pool even if he have no constants" issue
+␛[33mab906331394b␛[m HEAD@{543}: rebase (pick): whoo hoo I did something! :)
+␛[33m628ad7914f58␛[m HEAD@{544}: rebase (pick): Make fib be more real
+␛[33me5ad7ea67698␛[m HEAD@{545}: rebase (pick): *** empty log message ***
+␛[33m147dbdd611ae␛[m HEAD@{546}: rebase (pick): *** empty log message ***
+␛[33m07a717031897␛[m HEAD@{547}: rebase (pick): Added directory LiveVar/
+␛[33m2b9d47fba512␛[m HEAD@{548}: rebase (pick): Makefile for tools/tests/
+␛[33mef1302a7da62␛[m HEAD@{549}: rebase (pick): Driver to test IsPowerOf2. Could be extended for other library routines.
+␛[33meb98e995c108␛[m HEAD@{550}: rebase (pick): Add testcodegen target, and restrict which tests are run for it.
+␛[33m8e434f5bede3␛[m HEAD@{551}: rebase (pick): Added nonterminals for arithmetic operations where one operand is constant.
+␛[33m8846488b12e7␛[m HEAD@{552}: rebase (pick): Changed link line.
+␛[33mb9204403813b␛[m HEAD@{553}: rebase (pick): Add calls to NormalizeMethod() and to ScheduleInstructionsWithSSA().
+␛[33mad0b73970f13␛[m HEAD@{554}: rebase (pick): Makefile for InstrSched/
+␛[33m03d07894e506␛[m HEAD@{555}: rebase (pick): Remove source list.
+␛[33mbf1f10e707bf␛[m HEAD@{556}: rebase (pick): Added directory InstrSched.
+␛[33mdb25e211611a␛[m HEAD@{557}: rebase (pick): Major changes too hard to document :-)
+␛[33m6195f94883e7␛[m HEAD@{558}: rebase (pick): Added function MachineInstr::operandIsDefined(i) and decl for
+␛[33m4aa6182a26f1␛[m HEAD@{559}: rebase (pick): Extensive additions for supporting instruction scheduling.
+␛[33m21aba4339c60␛[m HEAD@{560}: rebase (pick): Added class MachineSchedInfo and several supporting classes
+␛[33md0513476dc87␛[m HEAD@{561}: rebase (pick): Implementation of instruction scheduling for LLVM.
+␛[33m3222a43515d4␛[m HEAD@{562}: rebase (pick): Class that encapsulates priority heuristics for instruction scheduling.
+␛[33ma3bb9d7ef0f4␛[m HEAD@{563}: rebase (pick): Scheduling DAG for instruction scheduling. Currently for a single basic block.
+␛[33mf4be165ab676␛[m HEAD@{564}: rebase (pick): Moved debug options declaration to header file, and moved
+␛[33mf914ba215bc2␛[m HEAD@{565}: rebase (pick): Moved function PrintMachineInstructions here.
+␛[33mfb1a19d9a411␛[m HEAD@{566}: rebase (pick): analyze() now checks to see that we don't analyze the same method twice.
+␛[33m9e8f74af6ec5␛[m HEAD@{567}: rebase (pick): *** empty log message ***
+␛[33m3a2656af412d␛[m HEAD@{568}: rebase (pick): Simplification transformations to normalize the code for later passes.
+␛[33mbbb02c1d7c9b␛[m HEAD@{569}: rebase (pick): Use const int instead of #define.
+␛[33md0b683357562␛[m HEAD@{570}: rebase (pick): Add copy and assignment operators for POIterator, and
+␛[33m9f98fb5b9284␛[m HEAD@{571}: rebase (pick): Added InstrSched library to link line.
+␛[33mdac45308ccd6␛[m HEAD@{572}: rebase (pick): I suck
+␛[33mff67dcc22be0␛[m HEAD@{573}: rebase (pick): Initial checkin of TargetData code
+␛[33m8472822ff914␛[m HEAD@{574}: rebase (pick): Remove target specific stuff from Type classes
+␛[33m13bd108c03e0␛[m HEAD@{575}: rebase (pick): Remove target specific method from MemAccessInst class
+␛[33m2771054dbf3e␛[m HEAD@{576}: rebase (pick): Convert to use the new factored out TargetData class
+␛[33mddadbddb187b␛[m HEAD@{577}: rebase (pick): Factor code out to the TargetData class
+␛[33m3e08de6cee86␛[m HEAD@{578}: rebase (pick): Use the new TargetData class to factor out some of the shared code
+␛[33m729c3d47e91e␛[m HEAD@{579}: rebase (pick): Remove target specific method.
+␛[33m5ca1a2bcbc44␛[m HEAD@{580}: rebase (pick): Remove target specific code, move to TargetData.cpp file
+␛[33m7cd798c969a4␛[m HEAD@{581}: rebase (pick): Support passing a data pointer to annotation factory methods
+␛[33m3b3efaeeaf76␛[m HEAD@{582}: rebase (pick): Demolish explicit source list
+␛[33m1afbb4027fae␛[m HEAD@{583}: rebase (pick): Extend annotations to pass data pointers around to the functions
+␛[33m74782cb4a340␛[m HEAD@{584}: rebase (pick): Add another TODO: sigh
+␛[33mab8c3000e11e␛[m HEAD@{585}: rebase (pick): Lots of new functionality
+␛[33ma9a8941bb775␛[m HEAD@{586}: rebase (pick): Remove explicit source list
+␛[33mf011d42626b3␛[m HEAD@{587}: rebase (pick): Add dependence to libvmcore.
+␛[33m37c91bae4bcd␛[m HEAD@{588}: rebase (pick): Make sure noone branches to the entry node of the method
+␛[33mee0ddad61d01␛[m HEAD@{589}: rebase (pick): Compile LLI
+␛[33md34454f43919␛[m HEAD@{590}: rebase (pick): Rename start methods to main so interpreter works easier
+␛[33m44dfadcd4a33␛[m HEAD@{591}: rebase (pick): Add annotation support
+␛[33m03d42fd345d1␛[m HEAD@{592}: rebase (pick): Handle case where there is no exit node from a flowgraph
+␛[33m6c329f4eaed8␛[m HEAD@{593}: rebase (pick): Changed an assertion message
+␛[33m350d117dbdd5␛[m HEAD@{594}: rebase (pick): Add annotation support to value
+␛[33m311767f056af␛[m HEAD@{595}: rebase (pick): * Add assertions
+␛[33m55c6be031f13␛[m HEAD@{596}: rebase (pick): Initial checkin of interpreter
+␛[33m3fdb0df0b0b2␛[m HEAD@{597}: rebase (pick): LV code on machine instructions
+␛[33m19e88d249e25␛[m HEAD@{598}: rebase (pick): LV info on machine instructions
+␛[33mb1dfaf6145ab␛[m HEAD@{599}: rebase (pick): Corrected the compilation error by making the ValOperator class a friend of
+␛[33m3059c0b24b7c␛[m HEAD@{600}: rebase (pick): Always set isDef for operand in position resultPos.
+␛[33m081ab0fa9e0f␛[m HEAD@{601}: rebase (pick): Changed SetMachineOpernad calls in Set3OperandsFromInstr so that the
+␛[33m6be8772e0463␛[m HEAD@{602}: rebase (pick): Changed case 64 to make the first arg of phi a defintion
+␛[33mabc698370478␛[m HEAD@{603}: rebase (pick): Can't use ref to stack value!
+␛[33m56e7b4262d3e␛[m HEAD@{604}: rebase (pick): Needed old conditions as well as new in skipToNextVal()!
+␛[33m2b2d58164051␛[m HEAD@{605}: rebase (pick): Bug fix in ValOpIterator: not moving past operand with NULL Value.
+␛[33m4a1a05bc1473␛[m HEAD@{606}: rebase (pick): *** empty log message ***
+␛[33m32525540235d␛[m HEAD@{607}: rebase (pick): added a default isDef arg to SetMachineOperand method - Ruchira
+␛[33mac7c6045f846␛[m HEAD@{608}: rebase (pick): Added isDef field to MachineOperand class - Ruchira
+␛[33mf0942ac597e7␛[m HEAD@{609}: rebase (pick): Add CC operand as 4th operand of SUBcc, and mark it as a def.
+␛[33m9568ebd1a049␛[m HEAD@{610}: rebase (pick): Use extra operand for instructions that set a CC register that
+␛[33m17d5bdb8c5dc␛[m HEAD@{611}: rebase (pick): Also, move burg rule to Makefile.common.
+␛[33m5efe6ec39c6f␛[m HEAD@{612}: rebase (pick): And add rule to create a .cpp source file from burg input file!
+␛[33m5b8a3ae17209␛[m HEAD@{613}: rebase (pick): Better still, lets move pathname for Burg to Makefile.common.
+␛[33m415c589a5b97␛[m HEAD@{614}: rebase (pick): Add path and options for burg.
+␛[33m15a90d21c83f␛[m HEAD@{615}: rebase (pick): Use full pathname for burg.
+␛[33m044f893ad519␛[m HEAD@{616}: rebase (pick): Allow numOperands of -1 for variable #operands.
+␛[33m6b7eebde250d␛[m HEAD@{617}: rebase (pick): Simplify command line options, and add option for printing
+␛[33m5ac12a3af462␛[m HEAD@{618}: rebase (pick): Had used the wrong option.
+␛[33m27df4e0f0c54␛[m HEAD@{619}: rebase (pick): Added tree nodes for Phi instructions.
+␛[33m3d470f658f50␛[m HEAD@{620}: rebase (pick): Generate tree nodes for Phi instructions.
+␛[33m5745231c1ee0␛[m HEAD@{621}: rebase (pick): Allow machine instructions with variable numbers of arguments.
+␛[33m3de046767b96␛[m HEAD@{622}: rebase (pick): Added dummy Phi instruction.
+␛[33m7df9d89320cb␛[m HEAD@{623}: rebase (pick): Generate dummy Phi machine instruction, plus a bug fix for BrCond(boolreg).
+␛[33m371350759bd5␛[m HEAD@{624}: rebase (pick): Added support for testing instruction selection on all but 2 tests.
+␛[33m09c28c22fde1␛[m HEAD@{625}: rebase (pick): Added class MachineCodeForBasicBlock.
+␛[33mee4ef4ffe10c␛[m HEAD@{626}: rebase (pick): Record machine instructions in the vector for each basic block.
+␛[33m75e6a0432e3b␛[m HEAD@{627}: rebase (pick): Added vector of machine instructions for the basic block.
+␛[33m6c523d7b3a45␛[m HEAD@{628}: rebase (pick): New test cases
+␛[33ma991e5fcc19d␛[m HEAD@{629}: rebase (pick): Remove some gross stuff
+␛[33m33162a8d8802␛[m HEAD@{630}: rebase (pick): Allow vararg method types with 0 fixed types
+␛[33m18a61fcb43a4␛[m HEAD@{631}: rebase (pick): Make error msg nicer
+␛[33mc3e2fe5af54b␛[m HEAD@{632}: rebase (pick): Enable the elimination of method prototypes that are not referenced
+␛[33m8fb736efbcdd␛[m HEAD@{633}: rebase (pick): * Make sure that the size of the type field can also control the output
+␛[33ma9dab08596d3␛[m HEAD@{634}: rebase (pick): * Add calls to failure template so that it is actually possible to debug
+␛[33m077a425d4516␛[m HEAD@{635}: rebase (pick): * Fix bugs
+␛[33m03c4f8933762␛[m HEAD@{636}: rebase (pick): * Enable the use of escaped literal strings
+␛[33m934c4b501a22␛[m HEAD@{637}: rebase (pick): Modify var names to make it apparant that the code is really generic
+␛[33m0a587153f15f␛[m HEAD@{638}: rebase (pick): Changes to make test scripts more reliable
+␛[33me67cf2e7e23d␛[m HEAD@{639}: rebase (pick): Add test of string constants
+␛[33mc20b0ebc51c4␛[m HEAD@{640}: rebase (pick): Added function printIndent.
+␛[33m841fdaf6e2f7␛[m HEAD@{641}: rebase (pick): Added a pointer hash function object for use in pointer maps.
+␛[33m65fb5153e342␛[m HEAD@{642}: rebase (pick): Make a function const.
+␛[33m0762b37e7677␛[m HEAD@{643}: rebase (pick): Remove lib/LLC library.
+␛[33mcf6a5702c91e␛[m HEAD@{644}: rebase (pick): Added several SPARC instructions including conditional move and SETHI.
+␛[33m1fc9217c15ee␛[m HEAD@{645}: rebase (pick): Remove redundant and unused functions.
+␛[33m76b1285bfdc7␛[m HEAD@{646}: rebase (pick): Added UltraSparcInstrInfo class to specialize class MachineInstrInfo.
+␛[33m6e560c22a4f9␛[m HEAD@{647}: rebase (pick): Eliminate unused function.
+␛[33m5384b204a5da␛[m HEAD@{648}: rebase (pick): Bug fixes:
+␛[33m898348afb52d␛[m HEAD@{649}: rebase (pick): Added MachineInstrInfo class and moved instruction-related members there.
+␛[33m0c2462a079ed␛[m HEAD@{650}: rebase (pick): Eliminate separate enum for operand register type.
+␛[33meac34ac45c71␛[m HEAD@{651}: rebase (pick): Work around a few 'sorting issues' with the bytecode output that causes the bytecode
+␛[33m94e2da805ed4␛[m HEAD@{652}: rebase (pick): Don't write out constants that do not have a name, they will be inlined.
+␛[33m0fb64b07f943␛[m HEAD@{653}: rebase (pick): Refactor some of the constant stuff so that we can return complex constant
+␛[33mad7945a175d6␛[m HEAD@{654}: rebase (pick): Add an arg to insertVal to allow us to prevent builtin types from being ignored
+␛[33mfe70c81141d7␛[m HEAD@{655}: rebase (pick): Add an arg to insertVal to allow us to prevent builtin types from being ignored
+␛[33mf2a10b61e2a7␛[m HEAD@{656}: rebase (pick): New test for varargs functions
+␛[33md7f49ed443ab␛[m HEAD@{657}: rebase (pick): Add library dep
+␛[33mfd413193db44␛[m HEAD@{658}: rebase (pick): Parenthesize output for expranalyze so that pointer stuff being multiplied isn't confusing
+␛[33m88bb8ebe01fd␛[m HEAD@{659}: rebase (pick): Build as before dis
+␛[33m392cb8a9804a␛[m HEAD@{660}: rebase (pick): Add support for extern varargs methods & varargs method calls
+␛[33m89cb2de0eeac␛[m HEAD@{661}: rebase (pick): Add support for extern varargs methods & varargs method calls
+␛[33maad7190b6bea␛[m HEAD@{662}: rebase (pick): Fix a bug when compiling 'shl ubyte * %var, ubyte 2'
+␛[33mb5d668969e65␛[m HEAD@{663}: rebase (pick): Filter out noncore stuff
+␛[33m36123a777b5e␛[m HEAD@{664}: rebase (pick): Fixed a bug exposed when doing something like this: <program> -notanoption --help
+␛[33ma9622c681ad6␛[m HEAD@{665}: rebase (pick): Changed printValue() to print constant value if the value is a constant.
+␛[33mbb2db6c88f8a␛[m HEAD@{666}: rebase (pick): *** empty log message ***
+␛[33m8d83c40582cc␛[m HEAD@{667}: rebase (pick): Doh! Wrong Optional flag. :(
+␛[33ma6c90bf6ee4c␛[m HEAD@{668}: rebase (pick): Add a comment indicating that there is documentation of the library
+␛[33ma98afe4b0579␛[m HEAD@{669}: rebase (pick): Initial checking of some rough documentation for commandline library
+␛[33m48fca76a95a8␛[m HEAD@{670}: rebase (pick): Change option name slightly
+␛[33mf62a2f2be6a9␛[m HEAD@{671}: rebase (pick): Minor changes to implementation of CommandLine library to let users override
+␛[33m6c74f799d80b␛[m HEAD@{672}: rebase (pick): Add a missing </a> tag
+␛[33m026bec7cf715␛[m HEAD@{673}: rebase (pick): Use the new Alias command line option
+␛[33md2ec898cfb0e␛[m HEAD@{674}: rebase (pick): CommandLine library cleanup. No longer use getValue/setValue, instead, just treat the commandline
+␛[33mf74319d29b56␛[m HEAD@{675}: rebase (pick): Doh! Wrong accessor. Caused 'can not read bytecode' errors. :(
+␛[33m104c6f0c01f6␛[m HEAD@{676}: rebase (pick): -help is verbose enough that we don't need this anymore
+␛[33mb0dcda34759b␛[m HEAD@{677}: rebase (pick): Eliminated the Unique class in favor of NonCopyable and NonCopyableV
+␛[33mec8abea1c777␛[m HEAD@{678}: rebase (pick): Moved inline/llvm/Tools/* to include/llvm/Support/*
+␛[33mf434f8970fdd␛[m HEAD@{679}: rebase (pick): Initial checkin
+␛[33mbd177131a770␛[m HEAD@{680}: rebase (pick): Fix coding style issues to actually attempt to be somewhat uniform
+␛[33mf4c632fabc9b␛[m HEAD@{681}: rebase (pick): Nonpolymorphic class, doesn't need a virtual dtor!
+␛[33m7bc807e14176␛[m HEAD@{682}: rebase (pick): Clean up hash table usage
+␛[33mefe8c7aa1cf0␛[m HEAD@{683}: rebase (pick): Removal of the redundant CompileContext wrapper
+␛[33mb099c14cc8ba␛[m HEAD@{684}: rebase (pick): Verbosify descriptions
+␛[33mb72d002be10f␛[m HEAD@{685}: rebase (pick): Large scale changes to implement new command line argument facility
+␛[33m23381cd5b5a1␛[m HEAD@{686}: rebase (pick): Remove dependence on command line library. Silly anyway.
+␛[33m4ee192c0ff7a␛[m HEAD@{687}: rebase (pick): Make it pickier
+␛[33m442f68038647␛[m HEAD@{688}: rebase (pick): Add flag for emacs so it realizes it's C++ code
+␛[33m99c4af7c6b12␛[m HEAD@{689}: rebase (pick): New test case
+␛[33m01ef66c762bb␛[m HEAD@{690}: rebase (pick): Privatize LLCOptions. It had no business being visible to the entire
+␛[33mb18d26deb43d␛[m HEAD@{691}: rebase (pick): Move private header into private directory
+␛[33m57cb798a4677␛[m HEAD@{692}: rebase (pick): Convert from using C style char*'s to strings.
+␛[33m144db6c30c7a␛[m HEAD@{693}: rebase (pick): Remove String file some more
+␛[33m78fc43ff73cb␛[m HEAD@{694}: rebase (pick): Remove stringutils.h file
+␛[33m3b9829cf7645␛[m HEAD@{695}: rebase (pick): Destroy the StringUtils.h file
+␛[33ma1f7c42bcb01␛[m HEAD@{696}: rebase (pick): Eliminate lots of unnecessary #includes and forward decls
+␛[33mf5e75c7e705d␛[m HEAD@{697}: rebase (pick): Eliminate many unneccesary #includes
+␛[33m1aa17f3bb25c␛[m HEAD@{698}: rebase (pick): Make code fit in 80 columns more
+␛[33mb95c07e35c7f␛[m HEAD@{699}: rebase (pick): Remove unneccesary #includes
+␛[33m5381f682dd30␛[m HEAD@{700}: rebase (pick): Exterminate nasty Cisms
+␛[33m11f554634433␛[m HEAD@{701}: rebase (pick): Refer to include/llvm/CodeGen not Codegen
+␛[33md2e18d70c558␛[m HEAD@{702}: rebase (pick): Instructions for use
+␛[33m34e368c59b5b␛[m HEAD@{703}: rebase (pick): Make sure we build all of the code!
+␛[33mf0d858ed34f1␛[m HEAD@{704}: rebase (pick): Renamed include/llvm/Codegen to include/llvm/CodeGen
+␛[33m6c8ccac2de98␛[m HEAD@{705}: rebase (pick): Fix code to be in a consistent style
+␛[33mc267a7d71c7b␛[m HEAD@{706}: rebase (pick): More minor reorganizations
+␛[33m51777d7f1b52␛[m HEAD@{707}: rebase (pick): Remove getTempValuesForMachineCode from the Instruction interface
+␛[33m21be61506817␛[m HEAD@{708}: rebase (pick): Filter out the sparc.burm.c file
+␛[33mef91903bfcbf␛[m HEAD@{709}: rebase (pick): Moved LLC subdir to the tools top level directory
+␛[33m0e90eb4b6eb7␛[m HEAD@{710}: rebase (pick): Make the makefile work
+␛[33m345e38ed07ac␛[m HEAD@{711}: rebase (pick): Add new ctor for ConstPoolBool
+␛[33m9d9614205cf1␛[m HEAD@{712}: rebase (pick): Add new constructor for const pool bool
+␛[33m363bdd9a0676␛[m HEAD@{713}: rebase (pick): Add support for casts
+␛[33m7fd6dcb064ef␛[m HEAD@{714}: rebase (pick): Add support for casting operators
+␛[33m61f218f640e2␛[m HEAD@{715}: rebase (pick): Support changed expression api
+␛[33m0d64b2ba0a9c␛[m HEAD@{716}: rebase (pick): More functionality, renamed API
+␛[33mdf5dbc8e3949␛[m HEAD@{717}: rebase (pick): Moved isIntegral to the Type system
+␛[33ma61ce81cc4d8␛[m HEAD@{718}: rebase (pick): Autodep functionality broken. Remove so we get successful builds
+␛[33m148b96074cee␛[m HEAD@{719}: rebase (pick): Version of testmemory to test alloca, load and store.
+␛[33m5153d313b0ce␛[m HEAD@{720}: rebase (pick): Used a bigger constant in loopfunc.ll that doesn't fit in immed field.
+␛[33m36eb43e26456␛[m HEAD@{721}: rebase (pick): Utility routines for simpler access to the value of an integer constant.
+␛[33me31cf51c03a4␛[m HEAD@{722}: rebase (pick): Program options class.
+␛[33m2339d0cf578d␛[m HEAD@{723}: rebase (pick): Driver and options for the llc compiler.
+␛[33m03cdc0b1bceb␛[m HEAD@{724}: rebase (pick): Description of the SPARC as a target architecture.
+␛[33mdd4b4355c99d␛[m HEAD@{725}: rebase (pick): Base clas for a description of a target architecture.
+␛[33m8a2e2fbd50e6␛[m HEAD@{726}: rebase (pick): Instruction selection via pattern matching on instruction trees using BURG.
+␛[33mfea7ff57c801␛[m HEAD@{727}: rebase (pick): *** empty log message ***
+␛[33mfae069f4e36b␛[m HEAD@{728}: rebase (pick): Added CodeGen, LLC, and Support.
+␛[33m24812650a87f␛[m HEAD@{729}: rebase (pick): General support utilities like a program options class and a StringMap
+␛[33m7c52e8197cf9␛[m HEAD@{730}: rebase (pick): CompileContext and options class for the llc compiler.
+␛[33maed61d90db66␛[m HEAD@{731}: rebase (pick): Header files for the target architecture description and for instruction
+␛[33m82015f75875f␛[m HEAD@{732}: rebase (pick): Added support for getting the dependence of an executable on its libs,
+␛[33m70d2dc737e0b␛[m HEAD@{733}: rebase (pick): Add isIntegral() method to SignedIntType and UnsignedIntType.
+␛[33mc7371d8afb38␛[m HEAD@{734}: rebase (pick): Provide simpler ways to extract the value of an integer constant.
+␛[33m15e79bcb6e4b␛[m HEAD@{735}: rebase (pick): Compute and cache information about the storage size and layout
+␛[33m6b94be0fa4af␛[m HEAD@{736}: rebase (pick): Provide uniform access to the pointer operand and to the index
+␛[33m2010845c92f1␛[m HEAD@{737}: rebase (pick): Added a representation of the machine instructions generated
+␛[33m213160e0bb9f␛[m HEAD@{738}: rebase (pick): Start of expression analysis support
+␛[33m9250c349b550␛[m HEAD@{739}: rebase (pick): Header to raise and lower representation
+␛[33m56dbc9359f2b␛[m HEAD@{740}: rebase (pick): Add support to call LevelRaise
+␛[33m6ffd08afd81c␛[m HEAD@{741}: rebase (pick): Update makefile for more accurate deps
+␛[33mf2df47febf1b␛[m HEAD@{742}: rebase (pick): Implement ensureTypeAvailable
+␛[33me06171c5109f␛[m HEAD@{743}: rebase (pick): Add support for constant propogation of multiplies
+␛[33mec9be9e818a5␛[m HEAD@{744}: rebase (pick): Factor out WriteAsOperand.
+␛[33m4bef44e0adfc␛[m HEAD@{745}: rebase (pick): Add a comment.
+␛[33mf012589e78ed␛[m HEAD@{746}: rebase (pick): Add multiply as a supported constant propogation operation
+␛[33m643641cb450c␛[m HEAD@{747}: rebase (pick): New function: WriteAsOperand.
+␛[33m80470d72e903␛[m HEAD@{748}: rebase (pick): Add new base class ConstPoolInt, useful for dealing with integral constants
+␛[33m7a5ca318dfe7␛[m HEAD@{749}: rebase (pick): Add new method, ensureTypeAvailable
+␛[33m9abf2d95c339␛[m HEAD@{750}: rebase (pick): Change is*Type to be a casting convertion operator
+␛[33ma7a79aafa026␛[m HEAD@{751}: rebase (pick): Add an function to BinaryOperator to swap the two operands
+␛[33mf8bb46fb137c␛[m HEAD@{752}: rebase (pick): Add short forms of the get*Type methods.
+␛[33m9dbc6bb6b44d␛[m HEAD@{753}: rebase (pick): Fix nasty typo
+␛[33md59d2aa4a97e␛[m HEAD@{754}: rebase (pick): Fix clean target
+␛[33mbf1c55b14525␛[m HEAD@{755}: rebase (pick): Compile source files in alphabetical order
+␛[33m02990b116ef2␛[m HEAD@{756}: rebase (pick): Fixed typo in comment
+␛[33mf5b88528d736␛[m HEAD@{757}: rebase (pick): Support external methods
+␛[33m643d6d93c309␛[m HEAD@{758}: rebase (pick): New test case for prototype support
+␛[33m12bb537e90da␛[m HEAD@{759}: rebase (pick): Reordered link line for correct static linking.
+␛[33m903f9efa3f84␛[m HEAD@{760}: rebase (pick): Changed default to building library archives instead of shared objects.
+␛[33maabc8315f101␛[m HEAD@{761}: rebase (pick): Implement forward/external declarations for methods.
+␛[33m64e2c4726aa8␛[m HEAD@{762}: rebase (pick): Implement forward/external declarations for methods. Also, emit an error if a method
+␛[33ma2be53991d96␛[m HEAD@{763}: rebase (pick): Rename 'isMethodExternal' to 'isExternal'
+␛[33maf58b501dadf␛[m HEAD@{764}: rebase (pick): Add notes on instruction selection pass
+␛[33m3be6a7da5434␛[m HEAD@{765}: rebase (pick): New testcase from GCC doing array operations
+␛[33m5702913064a2␛[m HEAD@{766}: rebase (pick): Add support for assembly printing fp constants
+␛[33m05c8093e0529␛[m HEAD@{767}: rebase (pick): Add support to the bytecode writer to recognize floating point constants
+␛[33m55f91192bf7c␛[m HEAD@{768}: rebase (pick): Add support to the bytecode reader to recognize floating point constants
+␛[33m828ae092b096␛[m HEAD@{769}: rebase (pick): Add support to the parser to recognize floating point constants
+␛[33m9d78fb9b25fa␛[m HEAD@{770}: rebase (pick): Add a function to convert a double to a string
+␛[33md25973d16cd9␛[m HEAD@{771}: rebase (pick): Add support to write and read a fixed amount of raw data
+␛[33mc35d12757fd4␛[m HEAD@{772}: rebase (pick): Add a note
+␛[33m94c6d03b6c82␛[m HEAD@{773}: rebase (pick): * ValueHolder now takes 3 arguments
+␛[33m67b11a5bd739␛[m HEAD@{774}: rebase (pick): Add knowledge about the struct form of the GetElementPtr instruction
+␛[33m06adb0b2ab08␛[m HEAD@{775}: rebase (pick): Remove dependency on the structure of ValueHolder.
+␛[33m0559fb6b55e4␛[m HEAD@{776}: rebase (pick): * The parent of a constant pool is a symtabvalue, not a value.
+␛[33mfb6d8d18898e␛[m HEAD@{777}: rebase (pick): The parent of a constant pool is a symtabvalue, not a value.
+␛[33mc20531f12219␛[m HEAD@{778}: rebase (pick): Added some comments, preparing to add global variables and method prototypes
+␛[33m39fae71357a5␛[m HEAD@{779}: rebase (pick): * The parent of a constant pool is a SymTabValue, not a value.
+␛[33me3812fad3a2d␛[m HEAD@{780}: rebase (pick): Made the following changes:
+␛[33mc6df40cee22e␛[m HEAD@{781}: rebase (pick): Added more todo's. Don't I ever accomplish anything?
+␛[33m6ee823f32e3d␛[m HEAD@{782}: rebase (pick): Add DebugValue member.
+␛[33mc8281fb7bdfe␛[m HEAD@{783}: rebase (pick): Made it not inline
+␛[33me0c85017da0a␛[m HEAD@{784}: rebase (pick): Add DebugValue global function
+␛[33ma93311112bbc␛[m HEAD@{785}: rebase (pick): Don't clean out the type plane of the constant pool... this is a hack. FIXME
+␛[33m97add160370e␛[m HEAD@{786}: rebase (pick): Make sure that types go in the constant pool if they are used.
+␛[33m3f0bab207223␛[m HEAD@{787}: rebase (pick): hasSideEffects should be marked virtual
+␛[33m08fc7cf1be14␛[m HEAD@{788}: rebase (pick): Modify notes
+␛[33m96f249a20298␛[m HEAD@{789}: rebase (pick): Fix stupid typo
+␛[33mc874f2e554d5␛[m HEAD@{790}: rebase (pick): Initial checkin of coding standards
+␛[33mc0abd659a4e3␛[m HEAD@{791}: rebase (pick): Updated documentation for load, store & getelementptr
+␛[33m8ff1023c5729␛[m HEAD@{792}: rebase (pick): add coverage of newly implemented instructions.
+␛[33m87ad59d49e91␛[m HEAD@{793}: rebase (pick): Implementation of Store & GetElementPtr
+␛[33m2b2b55bdec44␛[m HEAD@{794}: rebase (pick): Implement checking for new instructions
+␛[33m4fb6aa4a9e7a␛[m HEAD@{795}: rebase (pick): Add note
+␛[33me9d048cd6792␛[m HEAD@{796}: rebase (pick): Implemented shl, shl, & load instructions
+␛[33m5833b72ec4b1␛[m HEAD@{797}: rebase (pick): Moved Cast from being a Unary instruction to being an "Other" instruction
+␛[33m6b062514ff40␛[m HEAD@{798}: rebase (pick): Use the CDG to mark branches alive on demand.
+␛[33m3005d00fa8dd␛[m HEAD@{799}: rebase (pick): Add a new "addOperand" method to User.
+␛[33m4cb53fdaeffb␛[m HEAD@{800}: rebase (pick): Fixed post dominator frontiers! Yaay!
+␛[33maa86a73a5bec␛[m HEAD@{801}: rebase (pick): Neg instruction removed. Cast instruction implemented.
+␛[33m842d6e099476␛[m HEAD@{802}: rebase (pick): Neg instruction removed. TODO item fulfilled.
+␛[33m7550203543d2␛[m HEAD@{803}: rebase (pick): Removing unnecesary file
+␛[33m6c99b25c3bd8␛[m HEAD@{804}: rebase (pick): Convert BinaryOperand and UnaryOperator to only take instruction types of
+␛[33meea771ae35ce␛[m HEAD@{805}: rebase (pick): Broad superficial changes:
+␛[33m8b0f42aa64c1␛[m HEAD@{806}: rebase (pick): Devirtualize User::dropAllReferences
+␛[33mb6af5d386268␛[m HEAD@{807}: rebase (pick): Remove dtor's that simply call dropAllReferences
+␛[33m70707b9adf64␛[m HEAD@{808}: rebase (pick): Changed the fundemental architecture of Operands for Instructions. Now
+␛[33mbc4bfa70b8e0␛[m HEAD@{809}: rebase (pick): Changed memory reference instructions to store the result as the implicit
+␛[33mdd91a3d2d9e7␛[m HEAD@{810}: rebase (pick): Fixed some error messages to be nicer
+␛[33m7f723d15a495␛[m HEAD@{811}: rebase (pick): Add note about nuking Instruction::neg
+␛[33ma75385aa3c2e␛[m HEAD@{812}: rebase (pick): Initial checkin
+␛[33m93634e0499a7␛[m HEAD@{813}: rebase (pick): Add better support for post dominator information.
+␛[33m0528ba902343␛[m HEAD@{814}: rebase (pick): Add method to unify all exit nodes of a method
+␛[33m947db1d96a4f␛[m HEAD@{815}: rebase (pick): Implement support for postdominators, except in dom frontiers
+␛[33ma534bd635e5e␛[m HEAD@{816}: rebase (pick): New file, includes method to merge exit nodes together
+␛[33m9996c4da5186␛[m HEAD@{817}: rebase (pick): * Add a DominatorBase base class to maintain root of Dominator info
+␛[33m042a9c01050d␛[m HEAD@{818}: rebase (pick): * Added comments
+␛[33mb30075f1d1b2␛[m HEAD@{819}: rebase (pick): Update to include right file
+␛[33mb655a756d6a9␛[m HEAD@{820}: rebase (pick): Initial checkin of analyze tool.
+␛[33m2c1174ab6df2␛[m HEAD@{821}: rebase (pick): Build new analyze tool
+␛[33m8350bbd20ae5␛[m HEAD@{822}: rebase (pick): Added analyze to path for SetupOpt script
+␛[33mc705cdc36c17␛[m HEAD@{823}: rebase (pick): Add analyze tool to path for Setup script
+␛[33mb18d4fae85b6␛[m HEAD@{824}: rebase (pick): IntervalPartition was changed to inherit from vector<Interval*> instead of
+␛[33m743ecc7f0095␛[m HEAD@{825}: rebase (pick): IntervalPartition was changed to inherit from vector<Interval*> instead of
+␛[33mf95290eba1c4␛[m HEAD@{826}: rebase (pick): *** empty log message ***
+␛[33m39b38db21649␛[m HEAD@{827}: rebase (pick): Checkin of new Analysis result printing header
+␛[33mc16998cb96e5␛[m HEAD@{828}: rebase (pick): Code got moved from the lib/Assembly/Writer/IntervalWriter.cpp file to
+␛[33m49090bf698f5␛[m HEAD@{829}: rebase (pick): Remove code for printing out Analysis data structures. It got moved
+␛[33m2149e63cb883␛[m HEAD@{830}: rebase (pick): Update documentation a bit, correct #include guard
+␛[33mb048f8d4a4b3␛[m HEAD@{831}: rebase (pick): Add note about tool idea. Change command line of note to be more specific
+␛[33m62e192f9ef8f␛[m HEAD@{832}: rebase (pick): Add printing code for dominator info
+␛[33m5630a5fac34d␛[m HEAD@{833}: rebase (pick): Checkin of new dominator calculation routines. These will be improved in
+␛[33mee98cbc6c810␛[m HEAD@{834}: rebase (pick): Enable printing of dominator related information.
+␛[33m889fa47ccf94␛[m HEAD@{835}: rebase (pick): Add new anaysis routines for building dominator related information
+␛[33m98e49f4ca414␛[m HEAD@{836}: rebase (pick): Addition of 'deleter' function.
+␛[33mbac6bb0ae065␛[m HEAD@{837}: rebase (pick): Moved deleter to include/llvm/Tools/STLExtras.h
+␛[33mde19f162cc14␛[m HEAD@{838}: rebase (pick): Initial checkin. Should print dead instructions, except it doesn't do
+␛[33m4fb09389a03b␛[m HEAD@{839}: rebase (pick): Include ADCE pass, rename include/Opt directory to llvm/Optimizations
+␛[33md56c334ebb78␛[m HEAD@{840}: rebase (pick): Rename DoSparseConditionalConstantProp -> DoSCCP
+␛[33md8c1f57237a1␛[m HEAD@{841}: rebase (pick): Add note
+␛[33mc355930e34c8␛[m HEAD@{842}: rebase (pick): Add prototypes for ADCE pass
+␛[33ma9aaeed69342␛[m HEAD@{843}: rebase (pick): Rename DoSparseConditionalConstantProp to DoSCCP
+␛[33m82abf7e9b6fa␛[m HEAD@{844}: rebase (pick): Optimizations got their own header files
+␛[33mc49280c35c8a␛[m HEAD@{845}: rebase (pick): Implement reduceApply method
+␛[33m512b32b42708␛[m HEAD@{846}: rebase (pick): Add a new pop_back() method
+␛[33mc2d246ce3e77␛[m HEAD@{847}: rebase (pick): The ConstRules class got moved to the opt namespace
+␛[33m6167d0001fe5␛[m HEAD@{848}: rebase (pick): Add a reduceApply method
+␛[33md78e27809d32␛[m HEAD@{849}: rebase (pick): Split AllOpts.h into lots of little .h files.
+␛[33m0963fce4a854␛[m HEAD@{850}: rebase (pick): Export ConstantFoldTerminator, allow it to fold conditional branches to
+␛[33m849231387470␛[m HEAD@{851}: rebase (pick): Added documentation. Constant fold terminators.
+␛[33m6ff2d0ae85ce␛[m HEAD@{852}: rebase (pick): Added prototype for ConstantFoldTerminator
+␛[33m6fe27ce22949␛[m HEAD@{853}: rebase (pick): Add a check to avoid allowing V->replaceAllUsesWith(V)
+␛[33m3f6c78a176e1␛[m HEAD@{854}: rebase (pick): Add implementation of BasicBlock::removePredecessor code that was factored
+␛[33mba8f2c1f6a6f␛[m HEAD@{855}: rebase (pick): * Factored RemovePredecessorFromBlock into BasicBlock::removePredecessor
+␛[33mb0e4bdf5d6d0␛[m HEAD@{856}: rebase (pick): We need to make sure to remove PHI nodes in the successor that cannot be
+␛[33mca8d6d3dd907␛[m HEAD@{857}: rebase (pick): Added a note about a new verification the verifier should do
+␛[33m0686d990fbf0␛[m HEAD@{858}: rebase (pick): Added new removePredecessor method prototype
+␛[33m8930ec2756c1␛[m HEAD@{859}: rebase (pick): Added note, moved note
+␛[33m6109478c092c␛[m HEAD@{860}: rebase (pick): Fixed the obnoxious problem that caused an entire directory to rebuild
+␛[33mf2eab63950b5␛[m HEAD@{861}: rebase (pick): Miscellaneous cleanups:
+␛[33m63286b72d223␛[m HEAD@{862}: rebase (pick): Add a new Sparse Conditional Constant Propogation pass
+␛[33m324c5dcc9d82␛[m HEAD@{863}: rebase (pick): Add command line arguments for Constant Pool Merging & Sparse Conditional Constant Prop
+␛[33mb412bc074f36␛[m HEAD@{864}: rebase (pick): Put in test of SCCP. Watch out though, because we need to sort the
+␛[33mb4bb71fd0f0d␛[m HEAD@{865}: rebase (pick): Change to use the new GenericBinaryInst class. Support lots more operators.
+␛[33mb00b3f2b682d␛[m HEAD@{866}: rebase (pick): Misc cleanup
+␛[33m540c4ae24c8e␛[m HEAD@{867}: rebase (pick): * Expose DoConstantPoolMerging
+␛[33m955a4d740cb4␛[m HEAD@{868}: rebase (pick): Convert ugly postincrement to efficient preincrement
+␛[33m1dacaa7057bf␛[m HEAD@{869}: rebase (pick): * Move stuff around a bit.
+␛[33m926791f1ca54␛[m HEAD@{870}: rebase (pick): Add instructions to fold unary and binary instructions.
+␛[33m77090a9ae8e4␛[m HEAD@{871}: rebase (pick): * Use the new reduce_apply_bool template
+␛[33md564849afb96␛[m HEAD@{872}: rebase (pick): getBasicBlocks() is not needed anymore for reading Method data
+␛[33mc9c6da3ca1f7␛[m HEAD@{873}: rebase (pick): Added methods to make dealing with switches and branch instructions
+␛[33m5b8794782e8c␛[m HEAD@{874}: rebase (pick): Minor formating changes
+␛[33m259afbe701de␛[m HEAD@{875}: rebase (pick): Make a new GenericBinaryInst class, instead of providing lots of silly
+␛[33mf26fbe244a3c␛[m HEAD@{876}: rebase (pick): Convert postincrements to more efficient preincrements
+␛[33ma685acebd652␛[m HEAD@{877}: rebase (pick): Add a new slew of functions to allow dynamic_cast<> like operation for
+␛[33m49e5848f7266␛[m HEAD@{878}: rebase (pick): Add extra forwarding accessor methods so that getMethodList(), getBasicBlocks()
+␛[33m41a60e4b2e4f␛[m HEAD@{879}: rebase (pick): Add more notes
+␛[33m0f81680a2104␛[m HEAD@{880}: rebase (pick): Filter out some more stuff
+␛[33m0bf0d89d693b␛[m HEAD@{881}: rebase (pick): Moved UnaryOperator::create to InstrTypes.cpp until there is an iUnaryOps.cpp
+␛[33m4d5a89c84cd7␛[m HEAD@{882}: rebase (pick): Implement induction variable injection!
+␛[33mc463b997b86a␛[m HEAD@{883}: rebase (pick): Renamed get.*Operator to create seeing that it would have to be qualified
+␛[33mef4669a3e67b␛[m HEAD@{884}: rebase (pick): * Rename get.*Operator to create seeing that it would have to be qualified
+␛[33me51131d287ae␛[m HEAD@{885}: rebase (pick): A silly stupid test of the loop depth calculator was added. REMOVE in the
+␛[33md06ca69a78ce␛[m HEAD@{886}: rebase (pick): IntervalPartition: recode to use IntervalIterator to do all the work
+␛[33md2fd00e218cb␛[m HEAD@{887}: rebase (pick): Add a helper function bind_obj
+␛[33m7fc109749907␛[m HEAD@{888}: rebase (pick): Big changes. Interval*.h is now more or less finalized. IntervalPartition
+␛[33m5848055f471b␛[m HEAD@{889}: rebase (pick): CFG.h: change the iterator tag
+␛[33mc1eafb1d07ab␛[m HEAD@{890}: rebase (pick): ValueHolder's aren't interseting to me anymore
+␛[33mb1abed97808e␛[m HEAD@{891}: rebase (pick): New file due to the Intervals.h splitup
+␛[33m0724b3e90091␛[m HEAD@{892}: rebase (pick): New files due to the Intervals.h splitup
+␛[33mba91baa363b7␛[m HEAD@{893}: rebase (pick): Add a useless phi for testing with InductionVariables stuff
+␛[33mf916541417e3␛[m HEAD@{894}: rebase (pick): #include a different header due to Intervals.h splitting up
+␛[33m5329f8f73c86␛[m HEAD@{895}: rebase (pick): IntervalPartition & IntervalIterator classes have been split out into
+␛[33mfbea208252f0␛[m HEAD@{896}: rebase (pick): IntervalPartition & IntervalIterator classes have been split out into
+␛[33md828c7706db9␛[m HEAD@{897}: rebase (pick): Prepare for split between Interval, IntervalIterator, and IntervalIPartition
+␛[33m3b3d00dffb19␛[m HEAD@{898}: rebase (pick): Addition of IntervalIterator. Preparing for rename of Intervals.h to
+␛[33mf948fd9866ee␛[m HEAD@{899}: rebase (pick): Added notes
+␛[33md41887123b2e␛[m HEAD@{900}: rebase (pick): Implement a lot more functionality. Now loop invariant and linear
+␛[33md9b7e634b62b␛[m HEAD@{901}: rebase (pick): Interval::HeaderNode is now accessed thorugh an accessor function
+␛[33m32f9e9270229␛[m HEAD@{902}: rebase (pick): Add comments
+␛[33ma3eb9281f099␛[m HEAD@{903}: rebase (pick): Add accessor methods to binary/unary operators
+␛[33mb03e9bf9c388␛[m HEAD@{904}: rebase (pick): Add a space to the PHI node output code to make it look nicer
+␛[33m605e752f0429␛[m HEAD@{905}: rebase (pick): Moved printing code to the Assembly/Writer library.
+␛[33m8d6f5b857ebb␛[m HEAD@{906}: rebase (pick): Implement the new Interval::isLoop method
+␛[33mbc792603f8b8␛[m HEAD@{907}: rebase (pick): New header file defined with neeto utilities put in one place
+␛[33m3b59035da7ea␛[m HEAD@{908}: rebase (pick): Modified to use the new reduce_apply algorithm
+␛[33m58967efc5647␛[m HEAD@{909}: rebase (pick): * Added capability to print out an interval
+␛[33m0246e25d77a6␛[m HEAD@{910}: rebase (pick): * Added comments
+␛[33mf88d93ea7fac␛[m HEAD@{911}: rebase (pick): Add a test case: an irreducible flow graph.
+␛[33md9d7c6d1179e␛[m HEAD@{912}: rebase (pick): Get rid of a silly printout that isn't needed right now
+␛[33m667d489ab2c9␛[m HEAD@{913}: rebase (pick): Add note
+␛[33m7d9fb3ab2fe8␛[m HEAD@{914}: rebase (pick): New test case
+␛[33m6cdff3cad3c3␛[m HEAD@{915}: rebase (pick): Add capability to print a derived interval graph
+␛[33m7ac17927b805␛[m HEAD@{916}: rebase (pick): Add capability to build a derived interval graph
+␛[33m56e38307935f␛[m HEAD@{917}: rebase (pick): Factor the predeclarations of the CFG.h functionality into a seperate, new header
+␛[33mea614fef124f␛[m HEAD@{918}: rebase (pick): Initial Checking of Interval handling code
+␛[33m644acdbfe034␛[m HEAD@{919}: rebase (pick): Add stub for induction variable code
+␛[33m0a9fdd55c1ca␛[m HEAD@{920}: rebase (pick): Add a more complex test case
+␛[33m92e26fb33e21␛[m HEAD@{921}: rebase (pick): Add a test case for interval code
+␛[33m5a4847e078a6␛[m HEAD@{922}: rebase (pick): Add an optimization stub
+␛[33m423d0a2d3762␛[m HEAD@{923}: rebase (pick): New file: Interval analysis support
+␛[33mf0e51696b0f1␛[m HEAD@{924}: rebase (pick): Add a note
+␛[33m7b1bb4951dbd␛[m HEAD@{925}: rebase (pick): Filter out more stuff I don't want all the time
+␛[33mdf4258024997␛[m HEAD@{926}: rebase (pick): Removed silly test code
+␛[33m118b768314e8␛[m HEAD@{927}: rebase (pick): Added options to print out basic blocks in a variety of different orderings
+␛[33ma925ae543736␛[m HEAD@{928}: rebase (pick): Updates to work with new cfg namespace
+␛[33m0b9af59e24ef␛[m HEAD@{929}: rebase (pick): Implement support for writing VCG format output
+␛[33m388ad96269af␛[m HEAD@{930}: rebase (pick): Move contents to the cfg namespace.
+␛[33m91078f85b47e␛[m HEAD@{931}: rebase (pick): Updates to support
+␛[33mfba16076cade␛[m HEAD@{932}: rebase (pick): Updates to support
+␛[33mfc5655471d3e␛[m HEAD@{933}: rebase (pick): Updates to support
+␛[33m0a9d874b1031␛[m HEAD@{934}: rebase (pick): Updates to support
+␛[33mbcb3231d6613␛[m HEAD@{935}: rebase (pick): Update documentation to reflect:
+␛[33mdb7f6e6d79ea␛[m HEAD@{936}: rebase (pick): Moved getBinaryOperator to the BinaryOperator class and the getUnaryOperator
+␛[33m2cf6ee5926fe␛[m HEAD@{937}: rebase (pick): I actually got something done
+␛[33m783091c4f5c6␛[m HEAD@{938}: rebase (pick): Beautify the source a bit.
+␛[33m94ea386b0c0c␛[m HEAD@{939}: rebase (pick): Include support for reverse iteration.
+␛[33m059def0ab975␛[m HEAD@{940}: rebase (pick): Added a stupid testcase for iterators.
+␛[33mbe3f7a5b9a7a␛[m HEAD@{941}: rebase (pick): Added reverse depth first capability, fixed depth first capability
+␛[33m5b0379941c62␛[m HEAD@{942}: rebase (pick): Updated to work with new CFG.h file.
+␛[33m015520037831␛[m HEAD@{943}: rebase (pick): Moved iterators to the new CFG.h file.
+␛[33mb77ecaef3f49␛[m HEAD@{944}: rebase (pick): New file
+␛[33m2208b443367c␛[m HEAD@{945}: rebase (pick): inlining can change methods a second time, so don't rerun inliner when testing for
+␛[33md7ec7d53b0c1␛[m HEAD@{946}: rebase (pick): Add extra method to PHI node class
+␛[33m94a07501c89d␛[m HEAD@{947}: rebase (pick): Significant rework. DCE is still not done (see #ifdef'd out parts)
+␛[33m110f15739545␛[m HEAD@{948}: rebase (pick): Fixed to print slightly differently. Added use counts for labels
+␛[33madd1ace044cd␛[m HEAD@{949}: rebase (pick): Fixes for BB iterators, additional methods added for DCE pass
+␛[33m8a8e91d33707␛[m HEAD@{950}: rebase (pick): Extra comments
+␛[33m3bdcc96804e9␛[m HEAD@{951}: rebase (pick): Now does not include instruction files...
+␛[33mc6325331663d␛[m HEAD@{952}: rebase (pick): Initial revision
+␛[33mf3f54944c027␛[m HEAD@{953}: rebase (pick): New repository initialized by cvs2svn.
+␛[33m8b754e2f7567␛[m␛[33m (␛[m␛[1;31morigin/master␛[m␛[33m, ␛[m␛[1;31mfork/master␛[m␛[33m)␛[m HEAD@{954}: rebase (start): checkout origin/master
+␛[33m1dc8f4774d34␛[m HEAD@{955}: checkout: moving from main to arraytype
+␛[33m72ea6fbc150a␛[m HEAD@{956}: checkout: moving from recoverreturn to main
+␛[33m549498c110fa␛[m␛[33m (␛[m␛[1;32mrecoverreturn␛[m␛[33m)␛[m HEAD@{957}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+␛[33m500ba6619cf3␛[m HEAD@{958}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+␛[33m256e9d00f6a8␛[m HEAD@{959}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+␛[33m056fc2e74960␛[m HEAD@{960}: commit (amend): [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+␛[33md537c309a9d4␛[m HEAD@{961}: commit: [AST] Produce ReturnStmt containing RecoveryExpr when type is wrong
+␛[33m72ea6fbc150a␛[m HEAD@{962}: checkout: moving from main to recoverreturn
+␛[33m72ea6fbc150a␛[m HEAD@{963}: rebase (finish): returning to refs/heads/main
+␛[33m72ea6fbc150a␛[m HEAD@{964}: rebase (start): checkout origin/main
+␛[33m9dc4af327b12␛[m HEAD@{965}: checkout: moving from two to main
+␛[33m8062dae7812f␛[m␛[33m (␛[m␛[1;32mtwo␛[m␛[33m)␛[m HEAD@{966}: commit (amend): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+␛[33mc5ce4cbfc3cd␛[m HEAD@{967}: rebase (finish): returning to refs/heads/two
+␛[33mc5ce4cbfc3cd␛[m HEAD@{968}: rebase (pick): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+␛[33m72ea6fbc150a␛[m HEAD@{969}: rebase (start): checkout origin/main
+␛[33mc56122daac76␛[m HEAD@{970}: checkout: moving from iwyustdlib to two
+␛[33mf038610fb5f3␛[m HEAD@{971}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33me7f383b77f38␛[m HEAD@{972}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33m23650256334a␛[m HEAD@{973}: commit (amend): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33meb1c9e6fabaa␛[m HEAD@{974}: rebase (continue) (finish): returning to refs/heads/iwyustdlib
+␛[33meb1c9e6fabaa␛[m HEAD@{975}: rebase (continue): [clangd] Basic IncludeCleaner support for c/c++ standard library
+␛[33m128c6ed73b8f␛[m HEAD@{976}: rebase (start): checkout origin/main
+␛[33m2f3a9575f9ad␛[m HEAD@{977}: checkout: moving from stdlib to iwyustdlib
+␛[33mcdfb640fe9e8␛[m␛[33m (␛[m␛[1;32mstdlib␛[m␛[33m)␛[m HEAD@{978}: checkout: moving from prettify to stdlib
+␛[33m77cc7d2fd845␛[m␛[33m (␛[m␛[1;32mprettify␛[m␛[33m)␛[m HEAD@{979}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+␛[33m97d9713c55bc␛[m HEAD@{980}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+␛[33m0e1e531ca3ab␛[m HEAD@{981}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+␛[33m2dcf689f661e␛[m HEAD@{982}: commit (amend): [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+␛[33m22e53b9a3b3f␛[m HEAD@{983}: commit: [CodeCompletion][clangd] Clean __uglified parameter names in completion & hover
+␛[33m9dc4af327b12␛[m HEAD@{984}: checkout: moving from main to prettify
+␛[33m9dc4af327b12␛[m HEAD@{985}: reset: moving to HEAD
+␛[33m9dc4af327b12␛[m HEAD@{986}: reset: moving to HEAD
+␛[33m9dc4af327b12␛[m HEAD@{987}: checkout: moving from 9dc4af327b12dfbcf90fde1641cd649c6814bf98 to main
+␛[33m9dc4af327b12␛[m HEAD@{988}: checkout: moving from main to origin/main
+␛[33m2c644e2f71a5␛[m HEAD@{989}: commit: FFix feature name in 9dc4af327b12dfbcf90fde1641cd649c6814bf98
+␛[33m9dc4af327b12␛[m HEAD@{990}: rebase (finish): returning to refs/heads/main
+␛[33m9dc4af327b12␛[m HEAD@{991}: rebase (pick): Re-land "[clang] Add early exit when checking for const init of arrays."
+␛[33m4fedd4be385e␛[m HEAD@{992}: rebase (start): checkout origin/main
+␛[33ma3fd292fed18␛[m HEAD@{993}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+␛[33m70b8662a502c␛[m HEAD@{994}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+␛[33m2ff827ad7f2d␛[m HEAD@{995}: commit (amend): Re-land "[clang] Add early exit when checking for const init of arrays."
+␛[33m9ad5cbdb06d8␛[m HEAD@{996}: revert: Re-land "[clang] Add early exit when checking for const init of arrays."
+␛[33m6f1a501fddae␛[m HEAD@{997}: checkout: moving from tmplargs to main
+␛[33ma7b31d694812␛[m HEAD@{998}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m2142ae80cf59␛[m HEAD@{999}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m4669c22c0e70␛[m HEAD@{1000}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m99217d405b2b␛[m HEAD@{1001}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m86fa6ad9fb2b␛[m HEAD@{1002}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m0a7d62a75abf␛[m HEAD@{1003}: commit (amend): [CodeCompletion] Signature help for template argument lists
+␛[33m8b0170fa11c1␛[m HEAD@{1004}: commit: [CodeCompletion] Signature help for template argument lists
+␛[33m6f1a501fddae␛[m HEAD@{1005}: checkout: moving from main to tmplargs
+␛[33m6f1a501fddae␛[m HEAD@{1006}: reset: moving to HEAD
+␛[33m6f1a501fddae␛[m HEAD@{1007}: checkout: moving from aggregates to main
+␛[33m9cf82ca7e4ee␛[m HEAD@{1008}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33mc9f6b6b3f6a8␛[m HEAD@{1009}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33m7b37b2f933bd␛[m HEAD@{1010}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33me78f39a12189␛[m HEAD@{1011}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33m985a3b182774␛[m HEAD@{1012}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33ma7ab012a8ff1␛[m HEAD@{1013}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33m84c5ef8d6646␛[m HEAD@{1014}: commit (amend): [CodeCompletion] Signature help for aggregate initialization.
+␛[33m7e2d55fea796␛[m HEAD@{1015}: rebase (finish): returning to refs/heads/aggregates
+␛[33m7e2d55fea796␛[m HEAD@{1016}: rebase (pick): [CodeCompletion] Signature help for aggregate initialization.
+␛[33mb245d1eaec2d␛[m HEAD@{1017}: rebase (start): checkout bracehelp
+␛[33m6175a4ae0cfc␛[m HEAD@{1018}: checkout: moving from bracehelp to aggregates
+␛[33mb245d1eaec2d␛[m HEAD@{1019}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33mf648b926a983␛[m HEAD@{1020}: checkout: moving from aggregates to bracehelp
+␛[33m6175a4ae0cfc␛[m HEAD@{1021}: commit: [CodeCompletion] Signature help for aggregate initialization.
+␛[33mf648b926a983␛[m HEAD@{1022}: checkout: moving from bracehelp to aggregates
+␛[33mf648b926a983␛[m HEAD@{1023}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33md830368b01ba␛[m HEAD@{1024}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33m3fe02e425768␛[m HEAD@{1025}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33m3158a41d01e1␛[m HEAD@{1026}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33m8e451de571e7␛[m HEAD@{1027}: commit (amend): [CodeCompletion] Signature help for braced constructor calls
+␛[33mb35aa36a3e3f␛[m HEAD@{1028}: commit: [CodeCompletion] Signature help for braced constructor calls
+␛[33m6f1a501fddae␛[m HEAD@{1029}: checkout: moving from main to bracehelp
+␛[33m6f1a501fddae␛[m HEAD@{1030}: checkout: moving from completeinit to main
+␛[33m347a926ee355␛[m␛[33m (␛[m␛[1;32mcompleteinit␛[m␛[33m)␛[m HEAD@{1031}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+␛[33m9babb0590695␛[m HEAD@{1032}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+␛[33m91e9b7b90b4f␛[m HEAD@{1033}: commit (amend): [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+␛[33m0e1023621e0f␛[m HEAD@{1034}: commit: [CodeCompletion] (mostly) fix completion in incomplete C++ ctor initializers.
+␛[33m6f1a501fddae␛[m HEAD@{1035}: checkout: moving from main to completeinit
+␛[33m6f1a501fddae␛[m HEAD@{1036}: checkout: moving from configcompiler to main
+␛[33m0fa6fc0238fe␛[m HEAD@{1037}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33m8205faff5871␛[m HEAD@{1038}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33m27055788e902␛[m HEAD@{1039}: commit (amend): [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33mf9bdd0229665␛[m HEAD@{1040}: commit: [clangd] Add CompileFlags.Compiler option to override argv0
+␛[33m6f1a501fddae␛[m HEAD@{1041}: checkout: moving from main to configcompiler
+␛[33m6f1a501fddae␛[m HEAD@{1042}: checkout: moving from manglefilename to main
+␛[33mb3f0e3eeccc0␛[m␛[33m (␛[m␛[1;32mmanglefilename␛[m␛[33m)␛[m HEAD@{1043}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+␛[33m22ea16ea69e9␛[m HEAD@{1044}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+␛[33m8325fd69d14a␛[m HEAD@{1045}: commit (amend): [clangd] Adjust compile flags so they work when applied to other file(type)s.
+␛[33m0b435ba816ae␛[m HEAD@{1046}: commit: [clangd] Adjust compile flags so they work when applied to other file(type)s.
+␛[33m6f1a501fddae␛[m HEAD@{1047}: checkout: moving from main to manglefilename
+␛[33m6f1a501fddae␛[m HEAD@{1048}: checkout: moving from tidydiags to main
+␛[33m53abaad295f4␛[m HEAD@{1049}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33m8daae4149924␛[m HEAD@{1050}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33m95f3d66f621b␛[m HEAD@{1051}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33m6e4e13e32e9a␛[m HEAD@{1052}: commit (amend): [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33mb80c98fe991c␛[m HEAD@{1053}: commit: [clangd] Respect .clang-tidy ExtraArgs (-Wfoo only) when producing diagnostics
+␛[33m6f1a501fddae␛[m HEAD@{1054}: checkout: moving from main to tidydiags
+␛[33m6f1a501fddae␛[m HEAD@{1055}: rebase (finish): returning to refs/heads/main
+␛[33m6f1a501fddae␛[m HEAD@{1056}: rebase (pick): [clangd] Fix typo in test. NFC
+␛[33mdfa2ad1ad858␛[m HEAD@{1057}: rebase (start): checkout origin/main
+␛[33me5cc3319d413␛[m HEAD@{1058}: rebase (finish): returning to refs/heads/main
+␛[33me5cc3319d413␛[m HEAD@{1059}: rebase (pick): [clangd] Fix typo in test. NFC
+␛[33me751d97863fb␛[m HEAD@{1060}: rebase (start): checkout origin/main
+␛[33mbe44f91f4fca␛[m HEAD@{1061}: commit: [clangd] Fix typo in test. NFC
+␛[33mc2f2bb066b83␛[m HEAD@{1062}: reset: moving to HEAD
+␛[33mc2f2bb066b83␛[m HEAD@{1063}: rebase (finish): returning to refs/heads/main
+␛[33mc2f2bb066b83␛[m HEAD@{1064}: rebase (start): checkout origin/main
+␛[33m62bcb75ce510␛[m HEAD@{1065}: checkout: moving from usingtype to main
+␛[33maf27466c5039␛[m␛[33m (␛[m␛[1;32musingtype␛[m␛[33m)␛[m HEAD@{1066}: commit (amend): Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+␛[33mbbc902a8436d␛[m HEAD@{1067}: revert: Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+␛[33mcc56c66f27e1␛[m HEAD@{1068}: revert: Revert "[AST] Add UsingType: a sugar type for types found via UsingDecl"
+␛[33m565c17574dd0␛[m HEAD@{1069}: rebase (finish): returning to refs/heads/usingtype
+␛[33m565c17574dd0␛[m HEAD@{1070}: rebase (start): checkout origin/main
+␛[33me1600db19d63␛[m HEAD@{1071}: rebase (finish): returning to refs/heads/usingtype
+␛[33me1600db19d63␛[m HEAD@{1072}: rebase (pick): [AST] Add UsingType: a sugar type for types found via UsingDecl
+␛[33meb66f0662ad9␛[m HEAD@{1073}: rebase (start): checkout origin/main
+␛[33me5706481005a␛[m HEAD@{1074}: commit (amend): [AST] Add UsingType: a sugar type for types found via UsingDecl
+␛[33mc11ab3c47b88␛[m HEAD@{1075}: rebase (finish): returning to refs/heads/usingtype
+␛[33mc11ab3c47b88␛[m HEAD@{1076}: rebase (pick): [AST] Add UsingType: a sugar type for types found via UsingDecl
+␛[33m9cd55c7c3463␛[m HEAD@{1077}: rebase (start): checkout origin/main
+␛[33m77701d00dbf1␛[m HEAD@{1078}: commit (amend): [AST] Add UsingType: a sugar type for types found via UsingDecl
+␛[33m484ad728d0b4␛[m HEAD@{1079}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m38567f18b381␛[m HEAD@{1080}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m73794c07c44c␛[m HEAD@{1081}: rebase (finish): returning to refs/heads/usingtype
+␛[33m73794c07c44c␛[m HEAD@{1082}: rebase (pick): [AST] Add a sugar type for types found via UsingDecl
+␛[33m02fc8d5c9eb0␛[m HEAD@{1083}: rebase (start): checkout origin/main
+␛[33m528e4f3170f7␛[m HEAD@{1084}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m06aa0ecaf0ad␛[m HEAD@{1085}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33meb52127d5587␛[m HEAD@{1086}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m383df0a0d6e6␛[m HEAD@{1087}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33mc4f8be2c2d68␛[m HEAD@{1088}: rebase (continue) (finish): returning to refs/heads/usingtype
+␛[33mc4f8be2c2d68␛[m HEAD@{1089}: rebase (continue): [AST] Add a sugar type for types found via UsingDecl
+␛[33ma596a5fc128b␛[m HEAD@{1090}: rebase (start): checkout origin/main
+␛[33m25184d506c43␛[m HEAD@{1091}: checkout: moving from main to usingtype
+␛[33m62bcb75ce510␛[m HEAD@{1092}: commit: [AST] Add more testcases to QualTypeNamesTest. NFC
+␛[33m32dede65ae98␛[m HEAD@{1093}: rebase (finish): returning to refs/heads/main
+␛[33m32dede65ae98␛[m HEAD@{1094}: rebase (pick): [AST] Fix QualTypeNamesTest, which was spuriously passing
+␛[33m509153f1e7d1␛[m HEAD@{1095}: rebase (start): checkout origin/main
+␛[33m8b9423dcec0a␛[m HEAD@{1096}: commit: [AST] Fix QualTypeNamesTest, which was spuriously passing
+␛[33mebed0ca71561␛[m HEAD@{1097}: rebase (finish): returning to refs/heads/main
+␛[33mebed0ca71561␛[m HEAD@{1098}: rebase (start): checkout origin/main
+␛[33m6fef0ffa14a3␛[m HEAD@{1099}: checkout: moving from usingtype to main
+␛[33m25184d506c43␛[m HEAD@{1100}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m63d52ad6d61f␛[m HEAD@{1101}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33mc0adf4433852␛[m HEAD@{1102}: checkout: moving from origin to usingtype
+␛[33m8491272d5f8b␛[m␛[33m (␛[m␛[1;32morigin␛[m␛[33m)␛[m HEAD@{1103}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33m58f8efe72279␛[m HEAD@{1104}: rebase (finish): returning to refs/heads/origin
+␛[33m58f8efe72279␛[m HEAD@{1105}: rebase (pick): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33me7007b69d43b␛[m␛[33m (␛[m␛[1;32mfixx␛[m␛[33m)␛[m HEAD@{1106}: rebase (start): checkout origin/main
+␛[33mddcc1d2c88de␛[m HEAD@{1107}: checkout: moving from fixx to origin
+␛[33me7007b69d43b␛[m␛[33m (␛[m␛[1;32mfixx␛[m␛[33m)␛[m HEAD@{1108}: rebase (finish): returning to refs/heads/fixx
+␛[33me7007b69d43b␛[m␛[33m (␛[m␛[1;32mfixx␛[m␛[33m)␛[m HEAD@{1109}: rebase (pick): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33m54fc9eb9b313␛[m HEAD@{1110}: rebase (start): checkout origin/main
+␛[33m563ef9895a46␛[m HEAD@{1111}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33meb9db3287358␛[m HEAD@{1112}: rebase (finish): returning to refs/heads/fixx
+␛[33meb9db3287358␛[m HEAD@{1113}: rebase (pick): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33m529833377ccd␛[m␛[33m (␛[m␛[1;32mblock␛[m␛[33m)␛[m HEAD@{1114}: rebase (start): checkout origin/main
+␛[33m9344dda72035␛[m HEAD@{1115}: checkout: moving from block to fixx
+␛[33m529833377ccd␛[m␛[33m (␛[m␛[1;32mblock␛[m␛[33m)␛[m HEAD@{1116}: rebase (finish): returning to refs/heads/block
+␛[33m529833377ccd␛[m␛[33m (␛[m␛[1;32mblock␛[m␛[33m)␛[m HEAD@{1117}: rebase (pick): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+␛[33ma908ca6603ab␛[m HEAD@{1118}: rebase (start): checkout origin/main
+␛[33me65ea60537a7␛[m HEAD@{1119}: checkout: moving from asyncindex to block
+␛[33m747908384732␛[m␛[33m (␛[m␛[1;32masyncindex␛[m␛[33m)␛[m HEAD@{1120}: rebase (continue) (finish): returning to refs/heads/asyncindex
+␛[33m747908384732␛[m␛[33m (␛[m␛[1;32masyncindex␛[m␛[33m)␛[m HEAD@{1121}: rebase (continue): [clangd] Proof of concept: indexing after the preamble is built
+␛[33ma5927737daeb␛[m HEAD@{1122}: rebase (start): checkout origin/main
+␛[33m3f8dfb604b16␛[m HEAD@{1123}: checkout: moving from shared to asyncindex
+␛[33m6917f87b3c7c␛[m␛[33m (␛[m␛[1;32mshared␛[m␛[33m)␛[m HEAD@{1124}: rebase (finish): returning to refs/heads/shared
+␛[33m6917f87b3c7c␛[m␛[33m (␛[m␛[1;32mshared␛[m␛[33m)␛[m HEAD@{1125}: rebase (pick): [clangd] Cleanup unneeded use of shared_ptr. NFC
+␛[33m4299d8d0ce42␛[m HEAD@{1126}: rebase (start): checkout origin/main
+␛[33m998c40e04bec␛[m HEAD@{1127}: commit: [clangd] Cleanup unneeded use of shared_ptr. NFC
+␛[33m6fef0ffa14a3␛[m HEAD@{1128}: checkout: moving from main to shared
+␛[33m6fef0ffa14a3␛[m HEAD@{1129}: checkout: moving from asyncindex to main
+␛[33m3f8dfb604b16␛[m HEAD@{1130}: commit (amend): [clangd] Proof of concept: indexing after the preamble is built
+␛[33m69244a114c0c␛[m HEAD@{1131}: commit (amend): [clangd] Proof of concept: indexing after the preamble is built
+␛[33me0ed01382993␛[m HEAD@{1132}: commit: [clangd] Proof of concept: indexing after the preamble is built
+␛[33m6fef0ffa14a3␛[m HEAD@{1133}: checkout: moving from main to asyncindex
+␛[33m6fef0ffa14a3␛[m HEAD@{1134}: reset: moving to HEAD
+␛[33m6fef0ffa14a3␛[m HEAD@{1135}: reset: moving to HEAD
+␛[33m6fef0ffa14a3␛[m HEAD@{1136}: reset: moving to HEAD
+␛[33m6fef0ffa14a3␛[m HEAD@{1137}: reset: moving to HEAD
+␛[33m6fef0ffa14a3␛[m HEAD@{1138}: checkout: moving from main to main
+␛[33m6fef0ffa14a3␛[m HEAD@{1139}: rebase (finish): returning to refs/heads/main
+␛[33m6fef0ffa14a3␛[m HEAD@{1140}: rebase (start): checkout origin/main
+␛[33m26f6fbe2be1d␛[m HEAD@{1141}: checkout: moving from ccedit to main
+␛[33m782052f2decf␛[m␛[33m (␛[m␛[1;31mfork/ccedit␛[m␛[33m, ␛[m␛[1;32mccedit␛[m␛[33m)␛[m HEAD@{1142}: commit: [clangd] Prototype: code action to edit compile commands
+␛[33m26f6fbe2be1d␛[m HEAD@{1143}: checkout: moving from main to ccedit
+␛[33m26f6fbe2be1d␛[m HEAD@{1144}: reset: moving to origin/main
+␛[33mac431fc2cdf1␛[m␛[33m (␛[m␛[1;32mincomplete␛[m␛[33m)␛[m HEAD@{1145}: reset: moving to origin/main
+␛[33mc797aa934727␛[m HEAD@{1146}: revert: Revert "Revert "[Symbolizer][Debuginfo] Add debuginfod client to llvm-symbolizer.""
+␛[33mafa3c14e2ff9␛[m HEAD@{1147}: checkout: moving from block to main
+␛[33me65ea60537a7␛[m HEAD@{1148}: commit (amend): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+␛[33mc416e5d69d7e␛[m HEAD@{1149}: commit (amend): [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+␛[33m2c1e87eae0e2␛[m HEAD@{1150}: commit: [clangd] Disable support for clang-tidy suppression blocks (NOLINTBEGIN)
+␛[33mafa3c14e2ff9␛[m HEAD@{1151}: checkout: moving from main to block
+␛[33mafa3c14e2ff9␛[m HEAD@{1152}: checkout: moving from fixx to main
+␛[33m9344dda72035␛[m HEAD@{1153}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33mfb15c379c1f0␛[m HEAD@{1154}: commit (amend): [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33mbe240d2b0505␛[m HEAD@{1155}: commit: [Sema] Add FixIt when a C++ out-of-line method has extra/missing const
+␛[33mac431fc2cdf1␛[m␛[33m (␛[m␛[1;32mincomplete␛[m␛[33m)␛[m HEAD@{1156}: checkout: moving from incomplete to fixx
+␛[33mac431fc2cdf1␛[m␛[33m (␛[m␛[1;32mincomplete␛[m␛[33m)␛[m HEAD@{1157}: rebase (finish): returning to refs/heads/incomplete
+␛[33mac431fc2cdf1␛[m␛[33m (␛[m␛[1;32mincomplete␛[m␛[33m)␛[m HEAD@{1158}: rebase (pick): [clangd] ... and mark a new test as -fno-ms-compatibility too
+␛[33m30fc88bf1dc1␛[m HEAD@{1159}: rebase (start): checkout origin/main
+␛[33md3aa8d688374␛[m HEAD@{1160}: commit (amend): [clangd] ... and mark a new test as -fno-ms-compatibility too
+␛[33m03d0b9092b60␛[m HEAD@{1161}: commit: [clangd] ... and mark a new test as -fno-ms-compatibility too
+␛[33m1a68c14b577f␛[m HEAD@{1162}: reset: moving to HEAD
+␛[33m1a68c14b577f␛[m HEAD@{1163}: rebase (finish): returning to refs/heads/incomplete
+␛[33m1a68c14b577f␛[m HEAD@{1164}: rebase (pick): [clangd] Restore -fno-ms-compatibility to tests
+␛[33m8d897ec91528␛[m HEAD@{1165}: rebase (start): checkout origin/main
+␛[33mac5910467704␛[m HEAD@{1166}: commit: [clangd] Restore -fno-ms-compatibility to tests
+␛[33mc25ea488a39a␛[m HEAD@{1167}: reset: moving to HEAD
+␛[33mc25ea488a39a␛[m HEAD@{1168}: rebase (finish): returning to refs/heads/incomplete
+␛[33mc25ea488a39a␛[m HEAD@{1169}: rebase (pick): [clangd] Include-fixer: handle more "incomplete type" diags.
+␛[33ma55e51f9a64c␛[m HEAD@{1170}: rebase (start): checkout origin/main
+␛[33m11a2f06c37cc␛[m HEAD@{1171}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags.
+␛[33m8182fffc0500␛[m HEAD@{1172}: rebase (continue) (finish): returning to refs/heads/incomplete
+␛[33m8182fffc0500␛[m HEAD@{1173}: rebase (continue): [clangd] Include-fixer: handle more "incomplete type" diags.
+␛[33m86caf517bf05␛[m HEAD@{1174}: rebase (start): checkout origin/main
+␛[33m0958968acbe0␛[m HEAD@{1175}: checkout: moving from incompletenfc to incomplete
+␛[33ma8bf389f4146␛[m␛[33m (␛[m␛[1;32mincompletenfc␛[m␛[33m)␛[m HEAD@{1176}: rebase (finish): returning to refs/heads/incompletenfc
+␛[33ma8bf389f4146␛[m␛[33m (␛[m␛[1;32mincompletenfc␛[m␛[33m)␛[m HEAD@{1177}: rebase (pick): [clangd] Clean up some include-fixer tests. NFC
+␛[33m3ed47bcc9618␛[m HEAD@{1178}: rebase (start): checkout origin/main
+␛[33m76820d557062␛[m HEAD@{1179}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+␛[33mc28420e6737b␛[m HEAD@{1180}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+␛[33mb48226a052b2␛[m HEAD@{1181}: commit (amend): [clangd] Clean up some include-fixer tests. NFC
+␛[33m0958968acbe0␛[m HEAD@{1182}: checkout: moving from incomplete to incompletenfc
+␛[33m0958968acbe0␛[m HEAD@{1183}: checkout: moving from main to incomplete
+␛[33mafa3c14e2ff9␛[m HEAD@{1184}: checkout: moving from indeximplicit to main
+␛[33m0d64c65efac9␛[m␛[33m (␛[m␛[1;32mindeximplicit␛[m␛[33m)␛[m HEAD@{1185}: cherry-pick: [clangd] Indexing of standard library
+␛[33mee26e0ba082e␛[m␛[33m (␛[m␛[1;32mimplicitc␛[m␛[33m)␛[m HEAD@{1186}: checkout: moving from implicitc to indeximplicit
+␛[33mee26e0ba082e␛[m␛[33m (␛[m␛[1;32mimplicitc␛[m␛[33m)␛[m HEAD@{1187}: commit (amend): [clangd] Include fixer for missing functions in C
+␛[33m9ac5d003594e␛[m HEAD@{1188}: commit (amend): [clangd] Include fixer for missing functions in C
+␛[33m3b4429acb859␛[m HEAD@{1189}: commit (amend): [clangd] Include fixer for missing functions in C
+␛[33m1a75bc322127␛[m HEAD@{1190}: commit (amend): [clangd] Include fixer for missing functions in C
+␛[33m94ab31f3c7a8␛[m HEAD@{1191}: commit (amend): [clangd] Include fixer for missing functions in C
+␛[33m86494fa881eb␛[m HEAD@{1192}: commit: [clangd] Include fixer for missing functions in C
+␛[33mafa3c14e2ff9␛[m HEAD@{1193}: checkout: moving from main to implicitc
+␛[33mafa3c14e2ff9␛[m HEAD@{1194}: rebase (finish): returning to refs/heads/main
+␛[33mafa3c14e2ff9␛[m HEAD@{1195}: rebase (start): checkout origin/main
+␛[33md4865393b5da␛[m HEAD@{1196}: checkout: moving from incomplete to main
+␛[33m0958968acbe0␛[m HEAD@{1197}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+␛[33maa89c6b2a300␛[m HEAD@{1198}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+␛[33m153236d44e9a␛[m HEAD@{1199}: commit (amend): [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+␛[33m3f0f560caf3a␛[m HEAD@{1200}: commit: [clangd] Include-fixer: handle more "incomplete type" diags, clean up tests
+␛[33md4865393b5da␛[m HEAD@{1201}: checkout: moving from main to incomplete
+␛[33md4865393b5da␛[m HEAD@{1202}: reset: moving to HEAD
+␛[33md4865393b5da␛[m HEAD@{1203}: rebase (finish): returning to refs/heads/main
+␛[33md4865393b5da␛[m HEAD@{1204}: rebase (start): checkout origin/main
+␛[33me7f53ec78fe8␛[m HEAD@{1205}: checkout: moving from tblgen to main
+␛[33m7ef23188fe95␛[m␛[33m (␛[m␛[1;32mtblgen␛[m␛[33m)␛[m HEAD@{1206}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33m6bdf61f016e3␛[m HEAD@{1207}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33me249c35c3fb4␛[m HEAD@{1208}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33mfcf5c9f5bf33␛[m HEAD@{1209}: commit (amend): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33m7b3888a32700␛[m HEAD@{1210}: rebase (continue) (finish): returning to refs/heads/tblgen
+␛[33m7b3888a32700␛[m HEAD@{1211}: rebase (continue): [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33m4afae6f7c7f6␛[m HEAD@{1212}: rebase (start): checkout origin/main
+␛[33m34b10022310a␛[m HEAD@{1213}: commit: [clangd] Generate ConfigFragment/YAML/docs from one tablegen source
+␛[33me7f53ec78fe8␛[m HEAD@{1214}: checkout: moving from main to tblgen
+␛[33me7f53ec78fe8␛[m HEAD@{1215}: checkout: moving from two to main
+␛[33mc56122daac76␛[m HEAD@{1216}: reset: moving to HEAD
+␛[33mc56122daac76␛[m HEAD@{1217}: commit (amend): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+␛[33m2409b3d46f6c␛[m HEAD@{1218}: rebase (finish): returning to refs/heads/two
+␛[33m2409b3d46f6c␛[m HEAD@{1219}: rebase (pick): [Parse] Use empty RecoveryExpr when if/while/do/switch conditions fail to parse
+␛[33m2676759bf22e␛[m␛[33m (␛[m␛[1;32mmorefix␛[m␛[33m)␛[m HEAD@{1220}: rebase (start): checkout origin/main
+␛[33mad885f5a3eab␛[m␛[33m (␛[m␛[1;32marcpatch-D112996␛[m␛[33m)␛[m HEAD@{1221}: checkout: moving from morefix to two
+␛[33m2676759bf22e␛[m␛[33m (␛[m␛[1;32mmorefix␛[m␛[33m)␛[m HEAD@{1222}: rebase (finish): returning to refs/heads/morefix
+␛[33m2676759bf22e␛[m␛[33m (␛[m␛[1;32mmorefix␛[m␛[33m)␛[m HEAD@{1223}: rebase (pick): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33mb73cf6207efa␛[m HEAD@{1224}: rebase (start): checkout origin/main
+␛[33mda7ff2db120f␛[m HEAD@{1225}: rebase (finish): returning to refs/heads/morefix
+␛[33mda7ff2db120f␛[m HEAD@{1226}: rebase (pick): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33m77b2bb55671a␛[m HEAD@{1227}: rebase (start): checkout origin/main
+␛[33m8bf667957ed0␛[m HEAD@{1228}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33m56f023ff10d2␛[m HEAD@{1229}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33m805bac439319␛[m HEAD@{1230}: checkout: moving from origin to morefix
+␛[33mddcc1d2c88de␛[m HEAD@{1231}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33me4568ef854df␛[m HEAD@{1232}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33m9099df1707fe␛[m HEAD@{1233}: checkout: moving from stdlib to origin
+␛[33mcdfb640fe9e8␛[m␛[33m (␛[m␛[1;32mstdlib␛[m␛[33m)␛[m HEAD@{1234}: commit (amend): [clangd] Indexing of standard library
+␛[33m5c14772f82eb␛[m HEAD@{1235}: commit (amend): [clangd] Indexing of standard library
+␛[33m9bcdbb99a75b␛[m HEAD@{1236}: commit (amend): [clangd] WIP various stdlib indexing stuff
+␛[33m3e38a40b3f17␛[m HEAD@{1237}: commit (amend): [clangd] WIP various stdlib indexing stuff
+␛[33m4ac5a41a65fc␛[m HEAD@{1238}: rebase (finish): returning to refs/heads/stdlib
+␛[33m4ac5a41a65fc␛[m HEAD@{1239}: rebase (pick): [clangd] WIP various stdlib indexing stuff
+␛[33me1b9d805325b␛[m HEAD@{1240}: rebase (start): checkout origin/main
+␛[33m5330f525f264␛[m␛[33m (␛[m␛[1;32marcpatch-D105177␛[m␛[33m)␛[m HEAD@{1241}: checkout: moving from arcpatch-D105177 to stdlib
+␛[33m5330f525f264␛[m␛[33m (␛[m␛[1;32marcpatch-D105177␛[m␛[33m)␛[m HEAD@{1242}: checkout: moving from reserved to arcpatch-D105177
+␛[33m18cd067d0bfa␛[m␛[33m (␛[m␛[1;32mreserved␛[m␛[33m)␛[m HEAD@{1243}: commit (amend): [clangd] Don't index __reserved_names in headers.
+␛[33m06dd586e7297␛[m HEAD@{1244}: commit (amend): [clangd] Don't index __reserved_names in headers.
+␛[33me58aab51c464␛[m HEAD@{1245}: commit (amend): [clangd] Don't index __reserved_names in headers.
+␛[33m05a7bfb157fc␛[m HEAD@{1246}: commit: [clangd] Don't index __reserved_names in headers.
+␛[33me7f53ec78fe8␛[m HEAD@{1247}: checkout: moving from main to reserved
+␛[33me7f53ec78fe8␛[m HEAD@{1248}: checkout: moving from origin to main
+␛[33m9099df1707fe␛[m HEAD@{1249}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33m1557821a2bd2␛[m HEAD@{1250}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33m8c3bd3cc7478␛[m HEAD@{1251}: commit (amend): [clangd] Extend SymbolOrigin, stop serializing it
+␛[33mcb761c799928␛[m HEAD@{1252}: commit: [clangd] Extend SymbolOrigin, stop serializing it
+␛[33me7f53ec78fe8␛[m HEAD@{1253}: checkout: moving from main to origin
+␛[33me7f53ec78fe8␛[m HEAD@{1254}: rebase (finish): returning to refs/heads/main
+␛[33me7f53ec78fe8␛[m HEAD@{1255}: rebase (start): checkout origin/main
+␛[33mafc9e7517ada␛[m HEAD@{1256}: checkout: moving from arcpatch-D105177 to main
+␛[33m5330f525f264␛[m␛[33m (␛[m␛[1;32marcpatch-D105177␛[m␛[33m)␛[m HEAD@{1257}: commit (amend): [clangd] WIP various stdlib indexing stuff
+␛[33m4c58226488ee␛[m HEAD@{1258}: commit (amend): [clangd] WIP various stdlib indexing stuff
+␛[33mffbc79cbcc54␛[m HEAD@{1259}: commit (amend): [clangd] WIP various stdlib indexing stuff
+␛[33m5d5179621ede␛[m HEAD@{1260}: checkout: moving from main to arcpatch-D105177
+␛[33mafc9e7517ada␛[m HEAD@{1261}: rebase (finish): returning to refs/heads/main
+␛[33mafc9e7517ada␛[m HEAD@{1262}: rebase (start): checkout origin/main
+␛[33mf764a1a5bd7c␛[m HEAD@{1263}: checkout: moving from arcpatch-D105177 to main
+␛[33m5d5179621ede␛[m HEAD@{1264}: reset: moving to HEAD
+␛[33m5d5179621ede␛[m HEAD@{1265}: rebase (finish): returning to refs/heads/arcpatch-D105177
+␛[33m5d5179621ede␛[m HEAD@{1266}: rebase (pick): [clangd] Implemented indexing of standard library
+␛[33m25c7ec4fc622␛[m HEAD@{1267}: rebase (start): checkout origin/main
+␛[33m7f2bbbd16a82␛[m HEAD@{1268}: commit: [clangd] Implemented indexing of standard library
+␛[33m15acaad79d6e␛[m HEAD@{1269}: checkout: moving from main to arcpatch-D105177
+␛[33mf764a1a5bd7c␛[m HEAD@{1270}: checkout: moving from morefix to main
+␛[33m805bac439319␛[m HEAD@{1271}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33mc74d8a0e6f33␛[m HEAD@{1272}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33m86d15e9770ca␛[m HEAD@{1273}: commit (amend): [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33ma46d34a114b3␛[m HEAD@{1274}: commit: [clangd] Add fixes for clang "include <foo.h>" diagnostics
+␛[33mf764a1a5bd7c␛[m HEAD@{1275}: checkout: moving from main to morefix
+␛[33mf764a1a5bd7c␛[m HEAD@{1276}: checkout: moving from usingtype to main
+␛[33mc0adf4433852␛[m HEAD@{1277}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m661fde2dfe7c␛[m HEAD@{1278}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33mf38cd8c69f6d␛[m HEAD@{1279}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m4b8286a14790␛[m HEAD@{1280}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m480e5803b30f␛[m HEAD@{1281}: commit (amend): [AST] Add a sugar type for types found via UsingDecl
+␛[33m06cc1d22bf04␛[m HEAD@{1282}: rebase (finish): returning to refs/heads/usingtype
+␛[33m06cc1d22bf04␛[m HEAD@{1283}: rebase (pick): [AST] Add a sugar type for types found via UsingDecl
+␛[33mc133fb321f7c␛[m HEAD@{1284}: rebase (start): checkout origin/main
+␛[33m8545d9204be1␛[m HEAD@{1285}: rebase (abort): updating HEAD
+␛[33m8545d9204be1␛[m HEAD@{1286}: rebase (abort): updating HEAD
+␛[33m8545d9204be1␛[m HEAD@{1287}: checkout: moving from main to usingtype
+␛[33mf764a1a5bd7c␛[m HEAD@{1288}: rebase (finish): returning to refs/heads/main
+␛[33mf764a1a5bd7c␛[m HEAD@{1289}: rebase (pick): [clangd] Avoid possible crash: apply configuration after binding methods
+␛[33ma6f53afbcb4d␛[m HEAD@{1290}: rebase (finish): returning to refs/heads/main
+␛[33ma6f53afbcb4d␛[m HEAD@{1291}: rebase (start): checkout origin/main
+␛[33m5fedbd5b1815␛[m HEAD@{1292}: checkout: moving from main to usingtype
+␛[33m5fedbd5b1815␛[m HEAD@{1293}: checkout: moving from token to main
+␛[33m3878ad5e448c␛[m␛[33m (␛[m␛[1;32mtoken␛[m␛[33m)␛[m HEAD@{1294}: commit: xxx token
+␛[33m5fedbd5b1815␛[m HEAD@{1295}: checkout: moving from main to token
+␛[33m5fedbd5b1815␛[m HEAD@{1296}: rebase (finish): returning to refs/heads/main
+␛[33m5fedbd5b1815␛[m HEAD@{1297}: rebase (start): checkout origin/main
+␛[33me56d680fe870␛[m HEAD@{1298}: checkout: moving from iwyustdlib to main
+␛[33me56d680fe870␛[m HEAD@{1299}: checkout: moving from main to iwyustdlib
+␛[33me56d680fe870␛[m HEAD@{1300}: rebase (finish): returning to refs/heads/main
+␛[33me56d680fe870␛[m HEAD@{1301}: rebase (start): checkout origin/main
+␛[33m4fb62e138398␛[m HEAD@{1302}: checkout: moving from placeholders to main
+␛[33m8ac9d2ae5839␛[m␛[33m (␛[m␛[1;32mplaceholders␛[m␛[33m)␛[m HEAD@{1303}: rebase (finish): returning to refs/heads/placeholders
+␛[33m8ac9d2ae5839␛[m␛[33m (␛[m␛[1;32mplaceholders␛[m␛[33m)␛[m HEAD@{1304}: rebase (pick): [clangd] Fix function-arg-placeholder suppression with macros.
+␛[33mebda5e1e521f␛[m HEAD@{1305}: checkout: moving from main to placeholders
+␛[33mebda5e1e521f␛[m HEAD@{1306}: rebase (finish): returning to refs/heads/main
+␛[33mebda5e1e521f␛[m HEAD@{1307}: rebase (start): checkout origin/main
+␛[33m48b67dca2ccc␛[m HEAD@{1308}: checkout: moving from two to main
+␛[33mad885f5a3eab␛[m␛[33m (␛[m␛[1;32marcpatch-D112996␛[m␛[33m)␛[m HEAD@{1309}: checkout: moving from arcpatch-D112996 to two
+␛[33m63667c1896e1␛[m HEAD@{1310}: rebase (finish): returning to refs/heads/arcpatch-D112996
+␛[33m63667c1896e1␛[m HEAD@{1311}: rebase (pick): [clangd] Trace per-token time in clangd --check
+␛[33mf7500a4ef7bd␛[m HEAD@{1312}: rebase (pick): [CodeCompletion] Generally consider header files without extension
+␛[33m5fbcf677347e␛[m HEAD@{1313}: checkout: moving from main to arcpatch-D112996
+␛[33m48b67dca2ccc␛[m HEAD@{1314}: rebase (finish): returning to refs/heads/main
+␛[33m48b67dca2ccc␛[m HEAD@{1315}: rebase (start): checkout origin/main
+␛[33m627fa0b9a897␛[m HEAD@{1316}: reset: moving to HEAD
+␛[33m627fa0b9a897␛[m HEAD@{1317}: checkout: moving from enum to main
+␛[33m5880c835bdbe␛[m␛[33m (␛[m␛[1;32menum␛[m␛[33m)␛[m HEAD@{1318}: reset: moving to HEAD
+␛[33m5880c835bdbe␛[m␛[33m (␛[m␛[1;32menum␛[m␛[33m)␛[m HEAD@{1319}: reset: moving to HEAD
+␛[33m5880c835bdbe␛[m␛[33m (␛[m␛[1;32menum␛[m␛[33m)␛[m HEAD@{1320}: rebase (finish): returning to refs/heads/enum
+␛[33m5880c835bdbe␛[m␛[33m (␛[m␛[1;32menum␛[m␛[33m)␛[m HEAD@{1321}: rebase (pick): [Sema] Avoid crash in CheckEnumConstant with contains-error expressions
+␛[33m6a5e08cc4a5c␛[m␛[33m (␛[m␛[1;32mredecl␛[m␛[33m)␛[m HEAD@{1322}: rebase (finish): returning to refs/heads/redecl
+␛[33m6a5e08cc4a5c␛[m␛[33m (␛[m␛[1;32mredecl␛[m␛[33m)␛[m HEAD@{1323}: rebase (pick): [AST] injected-class-name is not a redecl, even in template specializations
+␛[33m627fa0b9a897␛[m HEAD@{1324}: checkout: moving from main to redecl
+␛[33m627fa0b9a897␛[m HEAD@{1325}: rebase (finish): returning to refs/heads/main
+␛[33m627fa0b9a897␛[m HEAD@{1326}: rebase (start): checkout origin/main
+␛[33mf06e33298266␛[m HEAD@{1327}: rebase (abort): updating HEAD
+␛[33mf06e33298266␛[m HEAD@{1328}: rebase (abort): updating HEAD
+␛[33mf06e33298266␛[m HEAD@{1329}: checkout: moving from specialfiles to main
+␛[33m73453e7adecb␛[m␛[33m (␛[m␛[1;32mspecialfiles␛[m␛[33m)␛[m HEAD@{1330}: rebase (finish): returning to refs/heads/specialfiles
+␛[33m73453e7adecb␛[m␛[33m (␛[m␛[1;32mspecialfiles␛[m␛[33m)␛[m HEAD@{1331}: rebase (pick): [clangd] Avoid expensive checks of buffer names in IncludeCleaner
+␛[33mde7494a33a5c␛[m␛[33m (␛[m␛[1;32mconstcrash␛[m␛[33m)␛[m HEAD@{1332}: rebase (finish): returning to refs/heads/constcrash
+␛[33mde7494a33a5c␛[m␛[33m (␛[m␛[1;32mconstcrash␛[m␛[33m)␛[m HEAD@{1333}: rebase (pick): [AST] fail rather than crash when const evaluating invalid c++ foreach
+␛[33mf06e33298266␛[m HEAD@{1334}: checkout: moving from main to specialfiles
+␛[33mf06e33298266␛[m HEAD@{1335}: rebase (finish): returning to refs/heads/main
+␛[33mf06e33298266␛[m HEAD@{1336}: rebase (start): checkout origin/main
+␛[33m9cc08cb02fdc␛[m␛[33m (␛[m␛[1;32mcrashtest␛[m␛[33m)␛[m HEAD@{1337}: checkout: moving from crashtest to constcrash
+␛[33m9cc08cb02fdc␛[m␛[33m (␛[m␛[1;32mcrashtest␛[m␛[33m)␛[m HEAD@{1338}: rebase (finish): returning to refs/heads/crashtest
+␛[33m9cc08cb02fdc␛[m␛[33m (␛[m␛[1;32mcrashtest␛[m␛[33m)␛[m HEAD@{1339}: rebase (pick): [clangd] Add integration test for crash handling
+␛[33m51be7061d025␛[m HEAD@{1340}: reset: moving to HEAD
+␛[33m51be7061d025␛[m HEAD@{1341}: checkout: moving from main to crashtest
+␛[33m51be7061d025␛[m HEAD@{1342}: commit: [clangd] Remove tricky integration test that flakes/fails on some platforms.
+␛[33m4373f3595f8e␛[m HEAD@{1343}: rebase (finish): returning to refs/heads/main
+␛[33m4373f3595f8e␛[m HEAD@{1344}: rebase (start): checkout origin/main
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1345}: checkout: moving from timer to main
+␛[33maa1ac2ae451e␛[m␛[33m (␛[m␛[1;32mflush␛[m␛[33m)␛[m HEAD@{1346}: checkout: moving from flush to timer
+␛[33maa1ac2ae451e␛[m␛[33m (␛[m␛[1;32mflush␛[m␛[33m)␛[m HEAD@{1347}: rebase (finish): returning to refs/heads/flush
+␛[33maa1ac2ae451e␛[m␛[33m (␛[m␛[1;32mflush␛[m␛[33m)␛[m HEAD@{1348}: rebase (pick): [clangd] Flush stderr after signal handlers run, so we always get the full stack/crash info
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1349}: checkout: moving from main to flush
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1350}: rebase (finish): returning to refs/heads/main
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1351}: rebase (start): checkout origin/main
+␛[33m4e91035387fa␛[m HEAD@{1352}: checkout: moving from arcpatch-D109506_1 to main
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1353}: rebase (finish): returning to refs/heads/arcpatch-D109506_1
+␛[33m045695f85cb8␛[m␛[33m (␛[m␛[1;32marcpatch-D109506_1␛[m␛[33m)␛[m HEAD@{1354}: rebase (pick): [clangd] Print current request context along with the stack trace
+␛[33m980c7f32490b␛[m HEAD@{1355}: checkout: moving from arcpatch-D111318 to arcpatch-D109506_1
+␛[33ma85b661d2ada␛[m␛[33m (␛[m␛[1;32marcpatch-D111318␛[m␛[33m)␛[m HEAD@{1356}: rebase (finish): returning to refs/heads/arcpatch-D111318
+␛[33ma85b661d2ada␛[m␛[33m (␛[m␛[1;32marcpatch-D111318␛[m␛[33m)␛[m HEAD@{1357}: rebase (pick): [clang][clangd] Improve signature help for variadic functions.
+␛[33m3964c1db915b␛[m HEAD@{1358}: checkout: moving from main to arcpatch-D111318
+␛[33m4e91035387fa␛[m HEAD@{1359}: rebase (finish): returning to refs/heads/main
+␛[33m4e91035387fa␛[m HEAD@{1360}: rebase (pick): [Support] Trim #include after b06df22
+␛[33m93c1b3caf052␛[m HEAD@{1361}: reset: moving to HEAD
+␛[33m93c1b3caf052␛[m HEAD@{1362}: rebase (finish): returning to refs/heads/main
+␛[33m93c1b3caf052␛[m HEAD@{1363}: rebase (start): checkout origin/main
+␛[33mc15bbdeafffb␛[m HEAD@{1364}: checkout: moving from arcpatch-D110825 to main
+␛[33m82fbd3412fec␛[m␛[33m (␛[m␛[1;32marcpatch-D110825␛[m␛[33m)␛[m HEAD@{1365}: commit: [clangd] Handle members of anon structs in SelectionTree
+␛[33m68e56bd320d7␛[m HEAD@{1366}: checkout: moving from main to arcpatch-D110825
+␛[33mc15bbdeafffb␛[m HEAD@{1367}: rebase (finish): returning to refs/heads/main
+␛[33mc15bbdeafffb␛[m HEAD@{1368}: rebase (start): checkout origin/main
+␛[33mbb9333c3504a␛[m HEAD@{1369}: checkout: moving from uid to main
+␛[33m22555bafe90d␛[m␛[33m (␛[m␛[1;32muid␛[m␛[33m)␛[m HEAD@{1370}: rebase (finish): returning to refs/heads/uid
+␛[33m22555bafe90d␛[m␛[33m (␛[m␛[1;32muid␛[m␛[33m)␛[m HEAD@{1371}: rebase (pick): [VFS] InMemoryFilesystem's UniqueIDs are a function of path and content.
+␛[33m722e705f72dd␛[m␛[33m (␛[m␛[1;32marcpatch-D110324␛[m␛[33m)␛[m HEAD@{1372}: checkout: moving from arcpatch-D110324 to uid
+␛[33m722e705f72dd␛[m␛[33m (␛[m␛[1;32marcpatch-D110324␛[m␛[33m)␛[m HEAD@{1373}: rebase (finish): returning to refs/heads/arcpatch-D110324
+␛[33m722e705f72dd␛[m␛[33m (␛[m␛[1;32marcpatch-D110324␛[m␛[33m)␛[m HEAD@{1374}: rebase (start): checkout origin/main
+␛[33meb209c13cce9␛[m HEAD@{1375}: rebase (finish): returning to refs/heads/arcpatch-D110324
+␛[33meb209c13cce9␛[m HEAD@{1376}: rebase (pick): clangd: Do not report inline overrides twice
+␛[33m5685eb950da7␛[m HEAD@{1377}: checkout: moving from main to arcpatch-D110324
+␛[33mbb9333c3504a␛[m HEAD@{1378}: rebase (finish): returning to refs/heads/main
+␛[33mbb9333c3504a␛[m HEAD@{1379}: rebase (start): checkout origin/main
+␛[33m61cc873a8ef1␛[m HEAD@{1380}: checkout: moving from arcpatch-D109506 to main