[clang] 229c95a - [CodeCompletion] Signature help for aggregate initialization.
via cfe-commits
cfe-commits at lists.llvm.org
Tue Jan 4 08:39:46 PST 2022
This commit appears to add a file "tl" which I suspect wasn't intended?
--paulr
> -----Original Message-----
> From: cfe-commits <cfe-commits-bounces at lists.llvm.org> On Behalf Of Sam
> McCall via cfe-commits
> Sent: Tuesday, January 4, 2022 10:01 AM
> To: cfe-commits at lists.llvm.org
> Subject: [clang] 229c95a - [CodeCompletion] Signature help for aggregate
> initialization.
>
>
> Author: Sam McCall
> Date: 2022-01-04T16:00:22+01:00
> New Revision: 229c95ab661d89d29a64bff014229b7c6d3ee8a1
>
> URL: https://urldefense.com/v3/__https://github.com/llvm/llvm-
> project/commit/229c95ab661d89d29a64bff014229b7c6d3ee8a1__;!!JmoZiZGBv3RvKR
> Sx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDXwjSN-5BvfmyXHYwZJDzsg$
> DIFF: https://urldefense.com/v3/__https://github.com/llvm/llvm-
> project/commit/229c95ab661d89d29a64bff014229b7c6d3ee8a1.diff__;!!JmoZiZGBv
> 3RvKRSx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDXwjSN-
> 5BvfmyXHY_PGieew$
>
> LOG: [CodeCompletion] Signature help for aggregate initialization.
>
> The "parameter list" is the list of fields which should be initialized.
> We introduce a new OverloadCandidate kind for this.
> It starts to become harder for CC consumers to handle all the cases for
> params, so I added some extra APIs on OverloadCandidate to abstract them.
>
> Includes some basic support for designated initializers.
> The same aggregate signature is shown, the current arg jumps after the
> one you just initialized. This follows C99 semantics for mixed
> designated/positional initializers (which clang supports in C++ as an
> extension)
> and is also a useful prompt for C++ as C++ designated initializers must be
> in order.
>
> Related bugs:
> -
> https://urldefense.com/v3/__https://github.com/clangd/clangd/issues/965__;
> !!JmoZiZGBv3RvKRSx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDXwjSN-
> 5BvfmyXHZM2H6KjA$
> -
> https://urldefense.com/v3/__https://github.com/clangd/clangd/issues/306__;
> !!JmoZiZGBv3RvKRSx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDXwjSN-
> 5BvfmyXHZe9W7eZQ$
>
> Differential Revision:
> https://urldefense.com/v3/__https://reviews.llvm.org/D116326__;!!JmoZiZGBv
> 3RvKRSx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDXwjSN-
> 5BvfmyXHZMd1DaPg$
>
> Added:
> tl
>
> Modified:
> clang-tools-extra/clangd/CodeComplete.cpp
> clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
> clang/include/clang/Sema/CodeCompleteConsumer.h
> clang/lib/Sema/CodeCompleteConsumer.cpp
> clang/lib/Sema/SemaCodeComplete.cpp
> clang/test/CodeCompletion/ctor-signature.cpp
>
> Removed:
>
>
>
> ##########################################################################
> ######
> diff --git a/clang-tools-extra/clangd/CodeComplete.cpp b/clang-tools-
> extra/clangd/CodeComplete.cpp
> index 53d8f0d6cdeb7..50388e08c30aa 100644
> --- a/clang-tools-extra/clangd/CodeComplete.cpp
> +++ b/clang-tools-extra/clangd/CodeComplete.cpp
> @@ -896,10 +896,7 @@ struct ScoredSignature {
> int paramIndexForArg(const CodeCompleteConsumer::OverloadCandidate
> &Candidate,
> int Arg) {
> int NumParams = Candidate.getNumParams();
> - if (const auto *F = Candidate.getFunction()) {
> - if (F->isVariadic())
> - ++NumParams;
> - } else if (auto *T = Candidate.getFunctionType()) {
> + if (auto *T = Candidate.getFunctionType()) {
> if (auto *Proto = T->getAs<FunctionProtoType>()) {
> if (Proto->isVariadic())
> ++NumParams;
> @@ -996,8 +993,7 @@ class SignatureHelpCollector final : public
> CodeCompleteConsumer {
> const ScoredSignature &R) {
> // Ordering follows:
> // - Less number of parameters is better.
> - // - Function is better than FunctionType which is better than
> - // Function Template.
> + // - Aggregate > Function > FunctionType > FunctionTemplate
> // - High score is better.
> // - Shorter signature is better.
> // - Alphabetically smaller is better.
> @@ -1009,18 +1005,22 @@ class SignatureHelpCollector final : public
> CodeCompleteConsumer {
> R.Quality.NumberOfOptionalParameters;
> if (L.Quality.Kind != R.Quality.Kind) {
> using OC = CodeCompleteConsumer::OverloadCandidate;
> - switch (L.Quality.Kind) {
> - case OC::CK_Function:
> - return true;
> - case OC::CK_FunctionType:
> - return R.Quality.Kind != OC::CK_Function;
> - case OC::CK_FunctionTemplate:
> - return false;
> - case OC::CK_Template:
> - assert(false && "Never see templates and other overloads
> mixed");
> - return false;
> - }
> - llvm_unreachable("Unknown overload candidate type.");
> + auto KindPriority = [&](OC::CandidateKind K) {
> + switch (K) {
> + case OC::CK_Aggregate:
> + return 1;
> + case OC::CK_Function:
> + return 2;
> + case OC::CK_FunctionType:
> + return 3;
> + case OC::CK_FunctionTemplate:
> + return 4;
> + case OC::CK_Template:
> + return 5;
> + }
> + llvm_unreachable("Unknown overload candidate type.");
> + };
> + return KindPriority(L.Quality.Kind) <
> KindPriority(R.Quality.Kind);
> }
> if (L.Signature.label.size() != R.Signature.label.size())
> return L.Signature.label.size() < R.Signature.label.size();
> @@ -1171,24 +1171,9 @@ class ParamNameCollector final : public
> CodeCompleteConsumer {
> "too many arguments");
>
> for (unsigned I = 0; I < NumCandidates; ++I) {
> - OverloadCandidate Candidate = Candidates[I];
> - NamedDecl *Param = nullptr;
> - if (auto *Func = Candidate.getFunction()) {
> - if (CurrentArg < Func->getNumParams())
> - Param = Func->getParamDecl(CurrentArg);
> - } else if (auto *Template = Candidate.getTemplate()) {
> - if (CurrentArg < Template->getTemplateParameters()->size())
> - Param = Template->getTemplateParameters()-
> >getParam(CurrentArg);
> - }
> -
> - if (!Param)
> - continue;
> - auto *Ident = Param->getIdentifier();
> - if (!Ident)
> - continue;
> - auto Name = Ident->getName();
> - if (!Name.empty())
> - ParamNames.insert(Name.str());
> + if (const NamedDecl *ND = Candidates[I].getParamDecl(CurrentArg))
> + if (const auto *II = ND->getIdentifier())
> + ParamNames.emplace(II->getName());
> }
> }
>
>
> diff --git a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
> b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
> index 9d5c57670be1f..52dee0fdc0e21 100644
> --- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
> +++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
> @@ -1294,6 +1294,25 @@ TEST(SignatureHelpTest, Constructors) {
> CheckBracedInit("int x(S); int i = x({^});");
> }
>
> +TEST(SignatureHelpTest, Aggregates) {
> + std::string Top = R"cpp(
> + struct S {
> + int a, b, c, d;
> + };
> + )cpp";
> + auto AggregateSig = Sig("S{[[int a]], [[int b]], [[int c]], [[int
> d]]}");
> + EXPECT_THAT(signatures(Top + "S s{^}").signatures,
> + UnorderedElementsAre(AggregateSig, Sig("S{}"),
> + Sig("S{[[const S &]]}"),
> + Sig("S{[[S &&]]}")));
> + EXPECT_THAT(signatures(Top + "S s{1,^}").signatures,
> + ElementsAre(AggregateSig));
> + EXPECT_EQ(signatures(Top + "S s{1,^}").activeParameter, 1);
> + EXPECT_THAT(signatures(Top + "S s{.c=3,^}").signatures,
> + ElementsAre(AggregateSig));
> + EXPECT_EQ(signatures(Top + "S s{.c=3,^}").activeParameter, 3);
> +}
> +
> TEST(SignatureHelpTest, OverloadInitListRegression) {
> auto Results = signatures(R"cpp(
> struct A {int x;};
>
> diff --git a/clang/include/clang/Sema/CodeCompleteConsumer.h
> b/clang/include/clang/Sema/CodeCompleteConsumer.h
> index 70c34703f0a00..41c495882b27b 100644
> --- a/clang/include/clang/Sema/CodeCompleteConsumer.h
> +++ b/clang/include/clang/Sema/CodeCompleteConsumer.h
> @@ -1018,6 +1018,9 @@ class CodeCompleteConsumer {
>
> /// The candidate is a template, template arguments are being
> completed.
> CK_Template,
> +
> + /// The candidate is aggregate initialization of a record type.
> + CK_Aggregate,
> };
>
> private:
> @@ -1040,17 +1043,32 @@ class CodeCompleteConsumer {
> /// The template overload candidate, available when
> /// Kind == CK_Template.
> const TemplateDecl *Template;
> +
> + /// The class being aggregate-initialized,
> + /// when Kind == CK_Aggregate
> + const RecordDecl *AggregateType;
> };
>
> public:
> OverloadCandidate(FunctionDecl *Function)
> - : Kind(CK_Function), Function(Function) {}
> + : Kind(CK_Function), Function(Function) {
> + assert(Function != nullptr);
> + }
>
> OverloadCandidate(FunctionTemplateDecl *FunctionTemplateDecl)
> - : Kind(CK_FunctionTemplate),
> FunctionTemplate(FunctionTemplateDecl) {}
> + : Kind(CK_FunctionTemplate),
> FunctionTemplate(FunctionTemplateDecl) {
> + assert(FunctionTemplateDecl != nullptr);
> + }
>
> OverloadCandidate(const FunctionType *Type)
> - : Kind(CK_FunctionType), Type(Type) {}
> + : Kind(CK_FunctionType), Type(Type) {
> + assert(Type != nullptr);
> + }
> +
> + OverloadCandidate(const RecordDecl *Aggregate)
> + : Kind(CK_Aggregate), AggregateType(Aggregate) {
> + assert(Aggregate != nullptr);
> + }
>
> OverloadCandidate(const TemplateDecl *Template)
> : Kind(CK_Template), Template(Template) {}
> @@ -1077,8 +1095,23 @@ class CodeCompleteConsumer {
> return Template;
> }
>
> + /// Retrieve the aggregate type being initialized.
> + const RecordDecl *getAggregate() const {
> + assert(getKind() == CK_Aggregate);
> + return AggregateType;
> + }
> +
> + /// Get the number of parameters in this signature.
> unsigned getNumParams() const;
>
> + /// Get the type of the Nth parameter.
> + /// Returns null if the type is unknown or N is out of range.
> + QualType getParamType(unsigned N) const;
> +
> + /// Get the declaration of the Nth parameter.
> + /// Returns null if the decl is unknown or N is out of range.
> + const NamedDecl *getParamDecl(unsigned N) const;
> +
> /// Create a new code-completion string that describes the function
> /// signature of this overload candidate.
> CodeCompletionString *
>
> diff --git a/clang/lib/Sema/CodeCompleteConsumer.cpp
> b/clang/lib/Sema/CodeCompleteConsumer.cpp
> index bb088fd5fe97f..fefe20941f179 100644
> --- a/clang/lib/Sema/CodeCompleteConsumer.cpp
> +++ b/clang/lib/Sema/CodeCompleteConsumer.cpp
> @@ -508,6 +508,7 @@
> CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
> return Type;
>
> case CK_Template:
> + case CK_Aggregate:
> return nullptr;
> }
>
> @@ -517,11 +518,80 @@
> CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
> unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const {
> if (Kind == CK_Template)
> return Template->getTemplateParameters()->size();
> - if (const auto *FPT =
> dyn_cast_or_null<FunctionProtoType>(getFunctionType()))
> - return FPT->getNumParams();
> +
> + if (Kind == CK_Aggregate) {
> + unsigned Count =
> + std::distance(AggregateType->field_begin(), AggregateType-
> >field_end());
> + if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType))
> + Count += CRD->getNumBases();
> + return Count;
> + }
> +
> + if (const auto *FT = getFunctionType())
> + if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
> + return FPT->getNumParams();
> +
> return 0;
> }
>
> +QualType
> +CodeCompleteConsumer::OverloadCandidate::getParamType(unsigned N) const {
> + if (Kind == CK_Aggregate) {
> + if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
> + if (N < CRD->getNumBases())
> + return std::next(CRD->bases_begin(), N)->getType();
> + N -= CRD->getNumBases();
> + }
> + for (const auto *Field : AggregateType->fields())
> + if (N-- == 0)
> + return Field->getType();
> + return QualType();
> + }
> +
> + if (Kind == CK_Template) {
> + TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
> + if (N < TPL->size())
> + if (const auto *D = dyn_cast<NonTypeTemplateParmDecl>(TPL-
> >getParam(N)))
> + return D->getType();
> + return QualType();
> + }
> +
> + if (const auto *FT = getFunctionType())
> + if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
> + if (N < FPT->getNumParams())
> + return FPT->getParamType(N);
> + return QualType();
> +}
> +
> +const NamedDecl *
> +CodeCompleteConsumer::OverloadCandidate::getParamDecl(unsigned N) const {
> + if (Kind == CK_Aggregate) {
> + if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
> + if (N < CRD->getNumBases())
> + return std::next(CRD->bases_begin(), N)->getType()-
> >getAsTagDecl();
> + N -= CRD->getNumBases();
> + }
> + for (const auto *Field : AggregateType->fields())
> + if (N-- == 0)
> + return Field;
> + return nullptr;
> + }
> +
> + if (Kind == CK_Template) {
> + TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
> + if (N < TPL->size())
> + return TPL->getParam(N);
> + return nullptr;
> + }
> +
> + // Note that if we only have a FunctionProtoType, we don't have param
> decls.
> + if (const auto *FD = getFunction()) {
> + if (N < FD->param_size())
> + return FD->getParamDecl(N);
> + }
> + return nullptr;
> +}
> +
> //===--------------------------------------------------------------------
> --===//
> // Code completion consumer implementation
> //===--------------------------------------------------------------------
> --===//
>
> diff --git a/clang/lib/Sema/SemaCodeComplete.cpp
> b/clang/lib/Sema/SemaCodeComplete.cpp
> index e2bf5edc7b5e7..e089f85420bc6 100644
> --- a/clang/lib/Sema/SemaCodeComplete.cpp
> +++ b/clang/lib/Sema/SemaCodeComplete.cpp
> @@ -2817,14 +2817,18 @@ formatBlockPlaceholder(const PrintingPolicy
> &Policy, const NamedDecl *BlockDecl,
> Optional<ArrayRef<QualType>> ObjCSubsts = None);
>
> static std::string
> -FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl
> *Param,
> - bool SuppressName = false, bool SuppressBlock =
> false,
> +FormatFunctionParameter(const PrintingPolicy &Policy,
> + const DeclaratorDecl *Param, bool SuppressName =
> false,
> + bool SuppressBlock = false,
> Optional<ArrayRef<QualType>> ObjCSubsts = None) {
> // Params are unavailable in FunctionTypeLoc if the FunctionType is
> invalid.
> // It would be better to pass in the param Type, which is usually
> available.
> // But this case is rare, so just pretend we fell back to int as
> elsewhere.
> if (!Param)
> return "int";
> + Decl::ObjCDeclQualifier ObjCQual = Decl::OBJC_TQ_None;
> + if (const auto *PVD = dyn_cast<ParmVarDecl>(Param))
> + ObjCQual = PVD->getObjCDeclQualifier();
> bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
> if (Param->getType()->isDependentType() ||
> !Param->getType()->isBlockPointerType()) {
> @@ -2840,8 +2844,7 @@ FormatFunctionParameter(const PrintingPolicy
> &Policy, const ParmVarDecl *Param,
> Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
> ObjCSubstitutionContext::Parameter);
> if (ObjCMethodParam) {
> - Result =
> - "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
> Type);
> + Result = "(" + formatObjCParamQualifiers(ObjCQual, Type);
> Result += Type.getAsString(Policy) + ")";
> if (Param->getIdentifier() && !SuppressName)
> Result += Param->getIdentifier()->getName();
> @@ -2878,8 +2881,7 @@ FormatFunctionParameter(const PrintingPolicy
> &Policy, const ParmVarDecl *Param,
>
> if (ObjCMethodParam) {
> Result = Type.getAsString(Policy);
> - std::string Quals =
> - formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
> + std::string Quals = formatObjCParamQualifiers(ObjCQual, Type);
> if (!Quals.empty())
> Result = "(" + Quals + " " + Result + ")";
> if (Result.back() != ')')
> @@ -3689,6 +3691,31 @@ const RawComment *clang::getParameterComment(
> return nullptr;
> }
>
> +static void AddOverloadAggregateChunks(const RecordDecl *RD,
> + const PrintingPolicy &Policy,
> + CodeCompletionBuilder &Result,
> + unsigned CurrentArg) {
> + unsigned ChunkIndex = 0;
> + auto AddChunk = [&](llvm::StringRef Placeholder) {
> + if (ChunkIndex > 0)
> + Result.AddChunk(CodeCompletionString::CK_Comma);
> + const char *Copy = Result.getAllocator().CopyString(Placeholder);
> + if (ChunkIndex == CurrentArg)
> + Result.AddCurrentParameterChunk(Copy);
> + else
> + Result.AddPlaceholderChunk(Copy);
> + ++ChunkIndex;
> + };
> + // Aggregate initialization has all bases followed by all fields.
> + // (Bases are not legal in C++11 but in that case we never get here).
> + if (auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
> + for (const auto &Base : CRD->bases())
> + AddChunk(Base.getType().getAsString(Policy));
> + }
> + for (const auto &Field : RD->fields())
> + AddChunk(FormatFunctionParameter(Policy, Field));
> +}
> +
> /// Add function overload parameter chunks to the given code completion
> /// string.
> static void AddOverloadParameterChunks(ASTContext &Context,
> @@ -3698,6 +3725,11 @@ static void AddOverloadParameterChunks(ASTContext
> &Context,
> CodeCompletionBuilder &Result,
> unsigned CurrentArg, unsigned
> Start = 0,
> bool InOptional = false) {
> + if (!Function && !Prototype) {
> + Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
> + return;
> + }
> +
> bool FirstParameter = true;
> unsigned NumParams =
> Function ? Function->getNumParams() : Prototype->getNumParams();
> @@ -3851,22 +3883,13 @@
> CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
>
> FunctionDecl *FDecl = getFunction();
> const FunctionProtoType *Proto =
> - dyn_cast<FunctionProtoType>(getFunctionType());
> - if (!FDecl && !Proto) {
> - // Function without a prototype. Just give the return type and a
> - // highlighted ellipsis.
> - const FunctionType *FT = getFunctionType();
> - Result.AddResultTypeChunk(Result.getAllocator().CopyString(
> - FT->getReturnType().getAsString(Policy)));
> - Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace
> - : CodeCompletionString::CK_LeftParen);
> - Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
> - Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace
> - : CodeCompletionString::CK_RightParen);
> - return Result.TakeString();
> - }
> + dyn_cast_or_null<FunctionProtoType>(getFunctionType());
>
> - if (FDecl) {
> + // First, the name/type of the callee.
> + if (getKind() == CK_Aggregate) {
> + Result.AddTextChunk(
> + Result.getAllocator().CopyString(getAggregate()->getName()));
> + } else if (FDecl) {
> if (IncludeBriefComments) {
> if (auto RC = getParameterComment(S.getASTContext(), *this,
> CurrentArg))
> Result.addBriefComment(RC->getBriefText(S.getASTContext()));
> @@ -3878,14 +3901,19 @@
> CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
> FDecl->getDeclName().print(OS, Policy);
> Result.AddTextChunk(Result.getAllocator().CopyString(OS.str()));
> } else {
> + // Function without a declaration. Just give the return type.
> Result.AddResultTypeChunk(Result.getAllocator().CopyString(
> - Proto->getReturnType().getAsString(Policy)));
> + getFunctionType()->getReturnType().getAsString(Policy)));
> }
>
> + // Next, the brackets and parameters.
> Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace
> : CodeCompletionString::CK_LeftParen);
> - AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto,
> Result,
> - CurrentArg);
> + if (getKind() == CK_Aggregate)
> + AddOverloadAggregateChunks(getAggregate(), Policy, Result,
> CurrentArg);
> + else
> + AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto,
> Result,
> + CurrentArg);
> Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace
> : CodeCompletionString::CK_RightParen);
>
> @@ -5926,18 +5954,18 @@ static QualType getParamType(Sema &SemaRef,
> // overload candidates.
> QualType ParamType;
> for (auto &Candidate : Candidates) {
> - // FIXME: handle non-type-template-parameters by merging with D116326
> - if (const auto *FType = Candidate.getFunctionType())
> - if (const auto *Proto = dyn_cast<FunctionProtoType>(FType))
> - if (N < Proto->getNumParams()) {
> - if (ParamType.isNull())
> - ParamType = Proto->getParamType(N);
> - else if (!SemaRef.Context.hasSameUnqualifiedType(
> - ParamType.getNonReferenceType(),
> - Proto->getParamType(N).getNonReferenceType()))
> - // Otherwise return a default-constructed QualType.
> - return QualType();
> - }
> + QualType CandidateParamType = Candidate.getParamType(N);
> + if (CandidateParamType.isNull())
> + continue;
> + if (ParamType.isNull()) {
> + ParamType = CandidateParamType;
> + continue;
> + }
> + if (!SemaRef.Context.hasSameUnqualifiedType(
> + ParamType.getNonReferenceType(),
> + CandidateParamType.getNonReferenceType()))
> + // Two conflicting types, give up.
> + return QualType();
> }
>
> return ParamType;
> @@ -6058,6 +6086,73 @@ QualType Sema::ProduceCallSignatureHelp(Expr *Fn,
> ArrayRef<Expr *> Args,
> return !CandidateSet.empty() ? ParamType : QualType();
> }
>
> +// Determine which param to continue aggregate initialization from after
> +// a designated initializer.
> +//
> +// Given struct S { int a,b,c,d,e; }:
> +// after `S{.b=1,` we want to suggest c to continue
> +// after `S{.b=1, 2,` we continue with d (this is legal C and ext in
> C++)
> +// after `S{.b=1, .a=2,` we continue with b (this is legal C and ext in
> C++)
> +//
> +// Possible outcomes:
> +// - we saw a designator for a field, and continue from the returned
> index.
> +// Only aggregate initialization is allowed.
> +// - we saw a designator, but it was complex or we couldn't find the
> field.
> +// Only aggregate initialization is possible, but we can't assist
> with it.
> +// Returns an out-of-range index.
> +// - we saw no designators, just positional arguments.
> +// Returns None.
> +static llvm::Optional<unsigned>
> +getNextAggregateIndexAfterDesignatedInit(const ResultCandidate
> &Aggregate,
> + ArrayRef<Expr *> Args) {
> + static constexpr unsigned Invalid =
> std::numeric_limits<unsigned>::max();
> + assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate);
> +
> + // Look for designated initializers.
> + // They're in their syntactic form, not yet resolved to fields.
> + IdentifierInfo *DesignatedFieldName = nullptr;
> + unsigned ArgsAfterDesignator = 0;
> + for (const Expr *Arg : Args) {
> + if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Arg)) {
> + if (DIE->size() == 1 && DIE->getDesignator(0)->isFieldDesignator())
> {
> + DesignatedFieldName = DIE->getDesignator(0)->getFieldName();
> + ArgsAfterDesignator = 0;
> + } else {
> + return Invalid; // Complicated designator.
> + }
> + } else if (isa<DesignatedInitUpdateExpr>(Arg)) {
> + return Invalid; // Unsupported.
> + } else {
> + ++ArgsAfterDesignator;
> + }
> + }
> + if (!DesignatedFieldName)
> + return llvm::None;
> +
> + // Find the index within the class's fields.
> + // (Probing getParamDecl() directly would be quadratic in number of
> fields).
> + unsigned DesignatedIndex = 0;
> + const FieldDecl *DesignatedField = nullptr;
> + for (const auto *Field : Aggregate.getAggregate()->fields()) {
> + if (Field->getIdentifier() == DesignatedFieldName) {
> + DesignatedField = Field;
> + break;
> + }
> + ++DesignatedIndex;
> + }
> + if (!DesignatedField)
> + return Invalid; // Designator referred to a missing field, give up.
> +
> + // Find the index within the aggregate (which may have leading bases).
> + unsigned AggregateSize = Aggregate.getNumParams();
> + while (DesignatedIndex < AggregateSize &&
> + Aggregate.getParamDecl(DesignatedIndex) != DesignatedField)
> + ++DesignatedIndex;
> +
> + // Continue from the index after the last named field.
> + return DesignatedIndex + ArgsAfterDesignator + 1;
> +}
> +
> QualType Sema::ProduceConstructorSignatureHelp(QualType Type,
> SourceLocation Loc,
> ArrayRef<Expr *> Args,
> @@ -6065,48 +6160,72 @@ QualType
> Sema::ProduceConstructorSignatureHelp(QualType Type,
> bool Braced) {
> if (!CodeCompleter)
> return QualType();
> + SmallVector<ResultCandidate, 8> Results;
>
> // A complete type is needed to lookup for constructors.
> - CXXRecordDecl *RD =
> - isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
> + RecordDecl *RD =
> + isCompleteType(Loc, Type) ? Type->getAsRecordDecl() : nullptr;
> if (!RD)
> return Type;
> - // FIXME: we don't support signature help for aggregate initialization,
> so
> - // don't offer a confusing partial list (e.g. the copy
> constructor).
> - if (Braced && RD->isAggregate())
> - return Type;
> + CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD);
> +
> + // Consider aggregate initialization.
> + // We don't check that types so far are correct.
> + // We also don't handle C99/C++17 brace-elision, we assume init-list
> elements
> + // are 1:1 with fields.
> + // FIXME: it would be nice to support "unwrapping" aggregates that
> contain
> + // a single subaggregate, like std::array<T, N> -> T __elements[N].
> + if (Braced && !RD->isUnion() &&
> + (!LangOpts.CPlusPlus || (CRD && CRD->isAggregate()))) {
> + ResultCandidate AggregateSig(RD);
> + unsigned AggregateSize = AggregateSig.getNumParams();
> +
> + if (auto NextIndex =
> + getNextAggregateIndexAfterDesignatedInit(AggregateSig, Args))
> {
> + // A designator was used, only aggregate init is possible.
> + if (*NextIndex >= AggregateSize)
> + return Type;
> + Results.push_back(AggregateSig);
> + return ProduceSignatureHelp(*this, Results, *NextIndex, OpenParLoc,
> + Braced);
> + }
> +
> + // Describe aggregate initialization, but also constructors below.
> + if (Args.size() < AggregateSize)
> + Results.push_back(AggregateSig);
> + }
>
> // FIXME: Provide support for member initializers.
> // FIXME: Provide support for variadic template constructors.
>
> - OverloadCandidateSet CandidateSet(Loc,
> OverloadCandidateSet::CSK_Normal);
> -
> - for (NamedDecl *C : LookupConstructors(RD)) {
> - if (auto *FD = dyn_cast<FunctionDecl>(C)) {
> - // FIXME: we can't yet provide correct signature help for
> initializer
> - // list constructors, so skip them entirely.
> - if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD))
> - continue;
> - AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
> Args,
> - CandidateSet,
> - /*SuppressUserConversions=*/false,
> - /*PartialOverloading=*/true,
> - /*AllowExplicit*/ true);
> - } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
> - if (Braced && LangOpts.CPlusPlus &&
> - isInitListConstructor(FTD->getTemplatedDecl()))
> - continue;
> + if (CRD) {
> + OverloadCandidateSet CandidateSet(Loc,
> OverloadCandidateSet::CSK_Normal);
> + for (NamedDecl *C : LookupConstructors(CRD)) {
> + if (auto *FD = dyn_cast<FunctionDecl>(C)) {
> + // FIXME: we can't yet provide correct signature help for
> initializer
> + // list constructors, so skip them entirely.
> + if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD))
> + continue;
> + AddOverloadCandidate(FD, DeclAccessPair::make(FD, C-
> >getAccess()), Args,
> + CandidateSet,
> + /*SuppressUserConversions=*/false,
> + /*PartialOverloading=*/true,
> + /*AllowExplicit*/ true);
> + } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
> + if (Braced && LangOpts.CPlusPlus &&
> + isInitListConstructor(FTD->getTemplatedDecl()))
> + continue;
>
> - AddTemplateOverloadCandidate(
> - FTD, DeclAccessPair::make(FTD, C->getAccess()),
> - /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
> - /*SuppressUserConversions=*/false,
> - /*PartialOverloading=*/true);
> + AddTemplateOverloadCandidate(
> + FTD, DeclAccessPair::make(FTD, C->getAccess()),
> + /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
> + /*SuppressUserConversions=*/false,
> + /*PartialOverloading=*/true);
> + }
> }
> + mergeCandidatesWithResults(*this, Results, CandidateSet, Loc,
> Args.size());
> }
>
> - SmallVector<ResultCandidate, 8> Results;
> - mergeCandidatesWithResults(*this, Results, CandidateSet, Loc,
> Args.size());
> return ProduceSignatureHelp(*this, Results, Args.size(), OpenParLoc,
> Braced);
> }
>
>
> diff --git a/clang/test/CodeCompletion/ctor-signature.cpp
> b/clang/test/CodeCompletion/ctor-signature.cpp
> index b02c8811bbcf0..8f0cfacfc1155 100644
> --- a/clang/test/CodeCompletion/ctor-signature.cpp
> +++ b/clang/test/CodeCompletion/ctor-signature.cpp
> @@ -42,13 +42,29 @@ int b3 = consumeBar({});
> // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:41:22 %s |
> FileCheck -check-prefix=CHECK-BRACED %s
>
> struct Aggregate {
> - // FIXME: no support for aggregates yet.
> - // CHECK-AGGREGATE-NOT: OVERLOAD: Aggregate{<#const Aggregate &#>}
> - // CHECK-AGGREGATE-NOT: OVERLOAD: {{.*}}first
> int first;
> int second;
> + int third;
> };
>
> -Aggregate a{};
> -// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:52:13 %s |
> FileCheck -check-prefix=CHECK-AGGREGATE %s
> +Aggregate a{1, 2, 3};
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:13 %s |
> FileCheck -check-prefix=CHECK-AGGREGATE-1 %s
> +// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#int first#>, int second, int
> third}
> +// CHECK-AGGREGATE-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:16 %s |
> FileCheck -check-prefix=CHECK-AGGREGATE-2 %s
> +// CHECK-AGGREGATE-2: OVERLOAD: Aggregate{int first, <#int second#>, int
> third}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:50:18 %s |
> FileCheck -check-prefix=CHECK-AGGREGATE-3 %s
> +// CHECK-AGGREGATE-3: OVERLOAD: Aggregate{int first, int second, <#int
> third#>}
>
> +Aggregate d{.second=1, .first=2, 3, 4, };
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:13 %s |
> FileCheck -check-prefix=CHECK-DESIG-1 %s
> +// CHECK-DESIG-1: OVERLOAD: Aggregate{<#int first#>, int second, int
> third}
> +// CHECK-DESIG-1: OVERLOAD: Aggregate{<#const Aggregate &#>}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:24 %s |
> FileCheck -check-prefix=CHECK-DESIG-2 %s
> +// CHECK-DESIG-2: OVERLOAD: Aggregate{int first, int second, <#int
> third#>}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:34 %s |
> FileCheck -check-prefix=CHECK-DESIG-3 %s
> +// CHECK-DESIG-3: OVERLOAD: Aggregate{int first, <#int second#>, int
> third}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:37 %s |
> FileCheck -check-prefix=CHECK-DESIG-4 %s
> +// CHECK-DESIG-4: OVERLOAD: Aggregate{int first, int second, <#int
> third#>}
> +// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:59:38 %s |
> FileCheck -check-prefix=CHECK-DESIG-5 %s --allow-empty
> +// CHECK-DESIG-5-NOT: OVERLOAD
>
> diff --git "a/tl\033" "b/tl\033"
> new file mode 100644
> index 0000000000000..1a124a4c5c135
> --- /dev/null
> +++ "b/tl\033"
> @@ -0,0 +1,1381 @@
> +[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
> diff erent "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
> diff erent 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
> diff erent 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
> diff erently. 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
>
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> https://urldefense.com/v3/__https://lists.llvm.org/cgi-
> bin/mailman/listinfo/cfe-
> commits__;!!JmoZiZGBv3RvKRSx!uQXxnl5TpWMb4VLqBh7hdl5PJBKwJUpwiqPOAlneE_FDX
> wjSN-5BvfmyXHZhTn6Eag$
More information about the cfe-commits
mailing list