class MyDiagnosticConsumer: public clang::DiagnosticConsumer
{
public:
    clang::DiagnosticConsumer* clone(clang::DiagnosticsEngine &Diags) const
    {
        return new MyDiagnosticConsumer;
    }
};

class MyModuleLoader: public clang::ModuleLoader
{
public:
    clang::Module* loadModule(clang::SourceLocation importLoc, clang::ModuleIdPath path, clang::Module::NameVisibilityKind visibility, bool isInclusionDirective)
    {
        //just do some parsing, forget about modules:
        return NULL;
    }
};

class MyASTConsumer: public clang::SemaConsumer
{
public:

    bool HandleTopLevelDecl(clang::DeclGroupRef D)
    {
        //never get here...
       
        return true;
    }

    void HandleTranslationUnit(clang::ASTContext &Ctx)
    {
        //not here either...
    }
};


int main()
{
    clang::IntrusiveRefCntPtr<clang::DiagnosticIDs> diags;
    MyDiagnosticConsumer dc;
    clang::DiagnosticsEngine de(diags, &dc, false);
    clang::Diagnostic d(&de);

    clang::TargetOptions to;
    to.Triple = llvm::Triple::getArchTypeName(llvm::Triple::x86);
    clang::TargetInfo* ti = clang::TargetInfo::CreateTargetInfo(de, to);

    clang::FileSystemOptions fso;
    clang::FileManager fm(fso);
    clang::SourceManager sm(de, fm);

    clang::LangOptions lo;
    clang::HeaderSearch hs(fm, de, lo, ti);

    MyModuleLoader ml;

    clang::Preprocessor p(de, lo, ti, sm, hs, ml);

    const clang::FileEntry* file = fm.getFile("test.cpp");
    sm.createMainFileID(file);
    p.EnterMainSourceFile();

    clang::IdentifierTable it(lo);
    clang::SelectorTable st;
    clang::Builtin::Context b_c;
    clang::ASTContext astContext(lo, sm, ti, it, st, b_c, 0);
    MyASTConsumer astConsumer;
    clang::Sema s(p, astContext, astConsumer);
    clang::Parser parser(p, s, false);

    parser.Initialize();
    clang::Parser::DeclGroupPtrTy result;
    while(!parser.ParseTopLevelDecl(result))
    {
        if ( result.get().isSingleDecl() )
        {
            clang::Decl* decl = result.get().getSingleDecl();

            clang::FunctionDecl* fd = clang::dyn_cast_or_null<clang::FunctionDecl>(decl);

            if ( fd->hasBody() )
            {
                clang::Stmt* s = fd->getBody();
                //don't know what to do with obtained statement...
            }
        }
        else if ( result.get().isDeclGroup() )
        {
            clang::DeclGroup& declGroup = result.get().getDeclGroup();
        }
    }

    getchar();

    return 0;
}

int main()
{
    return 5;
}

I have an LLVM pass that I am able to run with 'opt'. I now want this pass to be available for invocation via Clang. Any pointers on if and how to achieve this?

I have already looked through the document on writing a pass; I did not find this information on that page.

Sai Charan,

It would be relatively easy to merge the results in this setting. Note that, this happens to work well because the analyzer only deals with one file at a time, which does limit its power. Having whole program analyzes is something we are interested in doing in the future and it would greatly complicate the merging. Another problem with relying on this approach is that this would only give you file granularity. In principle, one might not need to reanalyze the whole file if one line in it changed. Coming up with a more general solution is a much more difficult problem.

Another feature that is somewhat related to this is identifying issues and tracking issues over time so that we could detect new warnings that just started appearing after a bunch of changes. This one is important to solve because many workflows involve looking at newly introduced issues. Hopefully, we'll get to this one soon.

If incremental analysis is something you would love to see in the analyzer, you can chime in by filing an enhancement request on llvm Bugzilla.

Cheers,

Anna.

I have been working on a mac with XCode for 2 months now and I'd like to be able to use CLang 3.1 because of C++11 features that would help me a lot writing less verbose code.

I am not a unix/bsd-like massive user so I lack a lot of knowledge about how to connect things in my work environnement.

Here are some questions:

 1. are there official plans or release date for Apple to upgrade XCode to Clang 3.1 once it's released? I assume that NO because I couldn't find anything online.

 2. assuming that I get clang 3.1 from the release package or from sources, once built, how to make XCode use this version?

I'm sorry for such noob question, I'm a bit lost in this new environnement...

I have found these informations: http://stackoverflow.com/questions/1718597/using-llvm-clang-2-6-with-xcode-3-2

But I am not sure if it's the good way to do it, as I need to be able to set the new compiler for a new project but keep the default compiler for previous projects...

Joel Lamotte

I am looking at using LLVM/Clang to automatically convert pointer declarations to fat pointers & the corresponding dereferences to something appropriate. I am looking for guidance on doing this. Will an LLVM pass be better suited to this or would this be better handled using Clang. Any guidance on getting started would be helpful.

Sai Charan,