Debloat some headers

[ariccio]

Summary

As discussed in "Code in headers" on llvm-dev, there are lots of headers with complex code in them. I've moved some complex constructors & destructors to implementation files, using Chromium's C++ Dos and Don'ts as a guide.

These changes are mostly in the Static Analyzer, as some files there take more than 30 seconds to compile.

On the mailing list, Chris Lattner said that we should measure how this affects the performance of the compiler generated by this code. Any idea how we do that?

Eh, Imma drop this patch. It turns out that there's not enough of an improvement here to justify the effort.

[craig.topper]

What's complex about the SVal constructors?

llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

143

I think previous discussions on the mail list have talked about only using emplace_back if the type isn't trivially copyable/moveable.

[ariccio]

llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

143

I did this as a drive by "fix", I thought it was a tad bit simpler than explicitly calling make_pair. I can change it back if you'd like.

[ariccio]

In D17130#349744, @craig.topper wrote:

What's complex about the SVal constructors?

I arbitrarily figured that classes that are more than twice-derived (is there a better way to say that) are complex. I don't think there was any particularly good reason there.

[mehdi_amini]

What the build time of clang before and after? (Your goal is to improve build time right?)

llvm/tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

private:
   Symbols &getInterestingSymbols();
   Regions &getInterestingRegions();
 
   void lazyInitializeInterestingSets();
   void pushInterestingSymbolsAndRegions();
   void popInterestingSymbolsAndRegions();
 
 public:
-  BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode)
-    : BT(bt), DeclWithIssue(nullptr), Description(desc), ErrorNode(errornode),
-      ConfigurationChangeToken(0), DoNotPrunePath(false) {}
+  BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode);
 
   BugReport(BugType& bt, StringRef shortDesc, StringRef desc,
-            const ExplodedNode *errornode)
-    : BT(bt), DeclWithIssue(nullptr), ShortDescription(shortDesc),
-      Description(desc), ErrorNode(errornode), ConfigurationChangeToken(0),
-      DoNotPrunePath(false) {}
-
-  BugReport(BugType &bt, StringRef desc, PathDiagnosticLocation l)
-    : BT(bt), DeclWithIssue(nullptr), Description(desc), Location(l),
-      ErrorNode(nullptr), ConfigurationChangeToken(0), DoNotPrunePath(false) {}
+            const ExplodedNode *errornode);
+
+  BugReport(BugType &bt, StringRef desc, PathDiagnosticLocation l);
 
   /// \brief Create a BugReport with a custom uniqueing location.
   ///
   /// The reports that have the same report location, description, bug type, and
   /// ranges are uniqued - only one of the equivalent reports will be presented
   /// to the user. This method allows to rest the location which should be used
   /// for uniquing reports. For example, memory leaks checker, could set this to
   /// the allocation site, rather then the location where the bug is reported.
   BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode,
-            PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique)
-    : BT(bt), DeclWithIssue(nullptr), Description(desc),
-      UniqueingLocation(LocationToUnique),
-      UniqueingDecl(DeclToUnique),
-      ErrorNode(errornode), ConfigurationChangeToken(0),
-      DoNotPrunePath(false) {}
+            PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique);
 
   virtual ~BugReport();
 
   const BugType& getBugType() const { return BT; }
   BugType& getBugType() { return BT; }
 
   const ExplodedNode *getErrorNode() const { return ErrorNode; }
 

llvm/tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

 
 class CheckerManager {
   const LangOptions LangOpts;
   AnalyzerOptionsRef AOptions;
   CheckName CurrentCheckName;
 
 public:
   CheckerManager(const LangOptions &langOpts,
-                 AnalyzerOptionsRef AOptions)
-    : LangOpts(langOpts),
-      AOptions(AOptions) {}
-
+                 AnalyzerOptionsRef AOptions);
   ~CheckerManager();
 
   void setCurrentCheckName(CheckName name) { CurrentCheckName = name; }
   CheckName getCurrentCheckName() const { return CurrentCheckName; }
 
   bool hasPathSensitiveCheckers() const;
 
   void finishedCheckerRegistration();

llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

 private:
   CoreEngine(const CoreEngine &) = delete;
   void operator=(const CoreEngine &) = delete;
 
   ExplodedNode *generateCallExitBeginNode(ExplodedNode *N);
 
 public:
   /// Construct a CoreEngine object to analyze the provided CFG.
-  CoreEngine(SubEngine &subengine, FunctionSummariesTy *FS)
-      : SubEng(subengine), WList(WorkList::makeDFS()),
-        BCounterFactory(G.getAllocator()), FunctionSummaries(FS) {}
+  CoreEngine(SubEngine &subengine, FunctionSummariesTy *FS);
 
   /// getGraph - Returns the exploded graph.
   ExplodedGraph &getGraph() { return G; }
 
   /// ExecuteWorkList - Run the worklist algorithm for a maximum number of
   ///  steps.  Returns true if there is still simulation state on the worklist.
   bool ExecuteWorkList(const LocationContext *L, unsigned Steps,
                        ProgramStateRef InitState);
public:
   bool wasBlocksExhausted() const { return !blocksExhausted.empty(); }
   bool hasWorkRemaining() const { return wasBlocksExhausted() || 
                                          WList->hasWork() || 
                                          wasBlockAborted(); }
 
   /// Inform the CoreEngine that a basic block was aborted because
   /// it could not be completely analyzed.
   void addAbortedBlock(const ExplodedNode *node, const CFGBlock *block) {
-    blocksAborted.push_back(std::make_pair(block, node));
+    blocksAborted.emplace_back(block, node);
   }
   
   WorkList *getWorkList() const { return WList.get(); }
 
   BlocksExhausted::const_iterator blocks_exhausted_begin() const {
     return blocksExhausted.begin();
   }
   BlocksExhausted::const_iterator blocks_exhausted_end() const {
public:
   void enqueueStmtNode(ExplodedNode *N, const CFGBlock *Block, unsigned Idx);
 };
 
 // TODO: Turn into a calss.
 struct NodeBuilderContext {
   const CoreEngine &Eng;
   const CFGBlock *Block;
   const LocationContext *LC;
-  NodeBuilderContext(const CoreEngine &E, const CFGBlock *B, ExplodedNode *N)
-    : Eng(E), Block(B), LC(N->getLocationContext()) { assert(B); }
+  NodeBuilderContext(const CoreEngine &E, const CFGBlock *B, ExplodedNode *N);
 
   /// \brief Return the CFGBlock associated with this builder.
   const CFGBlock *getBlock() const { return Block; }
 
   /// \brief Returns the number of times the current basic block has been
   /// visited on the exploded graph path.
   unsigned blockCount() const {
     return Eng.WList->getBlockCounter().getNumVisited(
bool hasNoSinksInFrontier() {
     for (iterator I = Frontier.begin(), E = Frontier.end(); I != E; ++I) {
       if ((*I)->isSink())
         return false;
     }
     return true;
   }
 
   /// Allow subclasses to finalize results before result_begin() is executed.
-  virtual void finalizeResults() {}
+  virtual void finalizeResults();
   
   ExplodedNode *generateNodeImpl(const ProgramPoint &PP,
                                  ProgramStateRef State,
                                  ExplodedNode *Pred,
                                  bool MarkAsSink = false);
 
 public:
   NodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
-              const NodeBuilderContext &Ctx, bool F = true)
-    : C(Ctx), Finalized(F), HasGeneratedNodes(false), Frontier(DstSet) {
-    Frontier.Add(SrcNode);
-  }
+              const NodeBuilderContext &Ctx, bool F = true);
 
   NodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
-              const NodeBuilderContext &Ctx, bool F = true)
-    : C(Ctx), Finalized(F), HasGeneratedNodes(false), Frontier(DstSet) {
-    Frontier.insert(SrcSet);
-    assert(hasNoSinksInFrontier());
-  }
+              const NodeBuilderContext &Ctx, bool F = true);
 
-  virtual ~NodeBuilder() {}
+  virtual ~NodeBuilder();
 
   /// \brief Generates a node in the ExplodedGraph.
   ExplodedNode *generateNode(const ProgramPoint &PP,
                              ProgramStateRef State,
                              ExplodedNode *Pred) {
     return generateNodeImpl(PP, State, Pred, false);
   }
 

 class NodeBuilderWithSinks: public NodeBuilder {
   void anchor() override;
 protected:
   SmallVector<ExplodedNode*, 2> sinksGenerated;
   ProgramPoint &Location;
 
 public:
   NodeBuilderWithSinks(ExplodedNode *Pred, ExplodedNodeSet &DstSet,
-                       const NodeBuilderContext &Ctx, ProgramPoint &L)
-    : NodeBuilder(Pred, DstSet, Ctx), Location(L) {}
+                       const NodeBuilderContext &Ctx, ProgramPoint &L);
 
   ExplodedNode *generateNode(ProgramStateRef State,
                              ExplodedNode *Pred,
                              const ProgramPointTag *Tag = nullptr) {
     const ProgramPoint &LocalLoc = (Tag ? Location.withTag(Tag) : Location);
     return NodeBuilder::generateNode(LocalLoc, State, Pred);
   }
 
class StmtNodeBuilder: public NodeBuilder {
   NodeBuilder *EnclosingBldr;
 public:
 
   /// \brief Constructs a StmtNodeBuilder. If the builder is going to process
   /// nodes currently owned by another builder(with larger scope), use
   /// Enclosing builder to transfer ownership.
   StmtNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
                   const NodeBuilderContext &Ctx,
-                  NodeBuilder *Enclosing = nullptr)
-    : NodeBuilder(SrcNode, DstSet, Ctx), EnclosingBldr(Enclosing) {
-    if (EnclosingBldr)
-      EnclosingBldr->takeNodes(SrcNode);
-  }
+                  NodeBuilder *Enclosing = nullptr);
 
   StmtNodeBuilder(ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
                   const NodeBuilderContext &Ctx,
-                  NodeBuilder *Enclosing = nullptr)
-    : NodeBuilder(SrcSet, DstSet, Ctx), EnclosingBldr(Enclosing) {
-    if (EnclosingBldr)
-      for (ExplodedNodeSet::iterator I = SrcSet.begin(),
-                                     E = SrcSet.end(); I != E; ++I )
-        EnclosingBldr->takeNodes(*I);
-  }
+                  NodeBuilder *Enclosing = nullptr);
 
   ~StmtNodeBuilder() override;
 
   using NodeBuilder::generateNode;
   using NodeBuilder::generateSink;
 
   ExplodedNode *generateNode(const Stmt *S,
                              ExplodedNode *Pred,
class BranchNodeBuilder: public NodeBuilder {
   const CFGBlock *DstF;
 
   bool InFeasibleTrue;
   bool InFeasibleFalse;
 
 public:
   BranchNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
                     const NodeBuilderContext &C,
-                    const CFGBlock *dstT, const CFGBlock *dstF)
-  : NodeBuilder(SrcNode, DstSet, C), DstT(dstT), DstF(dstF),
-    InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
-    // The branch node builder does not generate autotransitions.
-    // If there are no successors it means that both branches are infeasible.
-    takeNodes(SrcNode);
-  }
+                    const CFGBlock *dstT, const CFGBlock *dstF);
 
   BranchNodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
                     const NodeBuilderContext &C,
-                    const CFGBlock *dstT, const CFGBlock *dstF)
-  : NodeBuilder(SrcSet, DstSet, C), DstT(dstT), DstF(dstF),
-    InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
-    takeNodes(SrcSet);
-  }
+                    const CFGBlock *dstT, const CFGBlock *dstF);
 
   ExplodedNode *generateNode(ProgramStateRef State, bool branch,
                              ExplodedNode *Pred);
 
   const CFGBlock *getTargetBlock(bool branch) const {
     return branch ? DstT : DstF;
   }
 
class IndirectGotoNodeBuilder {
   CoreEngine& Eng;
   const CFGBlock *Src;
   const CFGBlock &DispatchBlock;
   const Expr *E;
   ExplodedNode *Pred;
 
 public:
   IndirectGotoNodeBuilder(ExplodedNode *pred, const CFGBlock *src, 
-                    const Expr *e, const CFGBlock *dispatch, CoreEngine* eng)
-    : Eng(*eng), Src(src), DispatchBlock(*dispatch), E(e), Pred(pred) {}
+                    const Expr *e, const CFGBlock *dispatch, CoreEngine* eng);
 
   class iterator {
     CFGBlock::const_succ_iterator I;
 
     friend class IndirectGotoNodeBuilder;
     iterator(CFGBlock::const_succ_iterator i) : I(i) {}
   public:
 

 class SwitchNodeBuilder {
   CoreEngine& Eng;
   const CFGBlock *Src;
   const Expr *Condition;
   ExplodedNode *Pred;
 
 public:
   SwitchNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
-                    const Expr *condition, CoreEngine* eng)
-  : Eng(*eng), Src(src), Condition(condition), Pred(pred) {}
+                    const Expr *condition, CoreEngine* eng);
 
   class iterator {
     CFGBlock::const_succ_reverse_iterator I;
 
     friend class SwitchNodeBuilder;
     iterator(CFGBlock::const_succ_reverse_iterator i) : I(i) {}
 
   public:

llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h

 class DefinedSVal : public DefinedOrUnknownSVal {
 private:
   // We want calling these methods to be a compiler error since they are
   // tautologically true/false.
   bool isUnknown() const = delete;
   bool isUnknownOrUndef() const = delete;
   bool isValid() const = delete;
 protected:
-  DefinedSVal() {}
-  explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
-    : DefinedOrUnknownSVal(d, isLoc, ValKind) {}
+  DefinedSVal();
+  explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind);
+
 private:
   friend class SVal;
   static bool isKind(const SVal& V) {
     return !V.isUnknownOrUndef();
   }
 };
 
 
 /// \brief Represents an SVal that is guaranteed to not be UnknownVal.
 class KnownSVal : public SVal {
-  KnownSVal() {}
+  KnownSVal();
   friend class SVal;
   static bool isKind(const SVal &V) {
     return !V.isUnknown();
   }
 public:
-  KnownSVal(const DefinedSVal &V) : SVal(V) {}
-  KnownSVal(const UndefinedVal &V) : SVal(V) {}
+  KnownSVal(const DefinedSVal &V);
+  KnownSVal(const UndefinedVal &V);
 };
 
 class NonLoc : public DefinedSVal {
 protected:
-  NonLoc() {}
-  explicit NonLoc(unsigned SubKind, const void *d)
-    : DefinedSVal(d, false, SubKind) {}
+  NonLoc();
+  explicit NonLoc(unsigned SubKind, const void *d);
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
 private:
   friend class SVal;
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind;
   }
 };
 
 class Loc : public DefinedSVal {
 protected:
-  Loc() {}
-  explicit Loc(unsigned SubKind, const void *D)
-  : DefinedSVal(const_cast<void*>(D), true, SubKind) {}
+  Loc();
+  explicit Loc(unsigned SubKind, const void *D);
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
-  static inline bool isLocType(QualType T) {
-    return T->isAnyPointerType() || T->isBlockPointerType() || 
-           T->isReferenceType() || T->isNullPtrType();
-  }
+  static bool isLocType(QualType T);
 
 private:
   friend class SVal;
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == LocKind;
   }
 };
 
 //==------------------------------------------------------------------------==//
 //  Subclasses of NonLoc.
 //==------------------------------------------------------------------------==//
 
 namespace nonloc {
 
 enum Kind {
 #define NONLOC_SVAL(Id, Parent) Id ## Kind,
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
 };
 
 /// \brief Represents symbolic expression.
 class SymbolVal : public NonLoc {
 public:
-  SymbolVal(SymbolRef sym) : NonLoc(SymbolValKind, sym) {}
+  SymbolVal(SymbolRef sym);
 
   SymbolRef getSymbol() const {
-    return (const SymExpr*) Data;
+    return static_cast<SymbolRef>(Data);
   }
 
   bool isExpression() const {
     return !isa<SymbolData>(getSymbol());
   }
 
 private:
   friend class SVal;
-  SymbolVal() {}
+  SymbolVal();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == SymbolValKind;
   }
 
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == SymbolValKind;
   }
 };
 
 /// \brief Value representing integer constant.
 class ConcreteInt : public NonLoc {
 public:
-  explicit ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {}
+  explicit ConcreteInt(const llvm::APSInt& V);
 
   const llvm::APSInt& getValue() const {
     return *static_cast<const llvm::APSInt*>(Data);
   }
 
   // Transfer functions for binary/unary operations on ConcreteInts.
   SVal evalBinOp(SValBuilder &svalBuilder, BinaryOperator::Opcode Op,
                  const ConcreteInt& R) const;
 
   ConcreteInt evalComplement(SValBuilder &svalBuilder) const;
 
   ConcreteInt evalMinus(SValBuilder &svalBuilder) const;
 
 private:
   friend class SVal;
-  ConcreteInt() {}
+  ConcreteInt();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == ConcreteIntKind;
   }
 
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == ConcreteIntKind;
   }
 };
 
 class LocAsInteger : public NonLoc {
   friend class ento::SValBuilder;
 
-  explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
-      : NonLoc(LocAsIntegerKind, &data) {
-    assert (data.first.getAs<Loc>());
-  }
-
+  explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data);
 public:
 
   Loc getLoc() const {
     const std::pair<SVal, uintptr_t> *D =
       static_cast<const std::pair<SVal, uintptr_t> *>(Data);
     return D->first.castAs<Loc>();
   }
 
   Loc getPersistentLoc() const {
     const std::pair<SVal, uintptr_t> *D =
       static_cast<const std::pair<SVal, uintptr_t> *>(Data);
     const SVal& V = D->first;
     return V.castAs<Loc>();
   }
 
   unsigned getNumBits() const {
     const std::pair<SVal, uintptr_t> *D =
       static_cast<const std::pair<SVal, uintptr_t> *>(Data);
     return D->second;
   }
 
 private:
   friend class SVal;
-  LocAsInteger() {}
+  LocAsInteger();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == LocAsIntegerKind;
   }
 
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == LocAsIntegerKind;
   }
 };
 
 class CompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
-  explicit CompoundVal(const CompoundValData* D) : NonLoc(CompoundValKind, D) {}
+  explicit CompoundVal(const CompoundValData* D);
 
 public:
   const CompoundValData* getValue() const {
     return static_cast<const CompoundValData*>(Data);
   }
 
   typedef llvm::ImmutableList<SVal>::iterator iterator;
   iterator begin() const;
   iterator end() const;
 
 private:
   friend class SVal;
-  CompoundVal() {}
+  CompoundVal();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind && V.getSubKind() == CompoundValKind;
   }
 
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == CompoundValKind;
   }
 };
 
 class LazyCompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
-  explicit LazyCompoundVal(const LazyCompoundValData *D)
-    : NonLoc(LazyCompoundValKind, D) {}
+  explicit LazyCompoundVal(const LazyCompoundValData *D);
 public:
   const LazyCompoundValData *getCVData() const {
     return static_cast<const LazyCompoundValData*>(Data);
   }
   const void *getStore() const;
   const TypedValueRegion *getRegion() const;
 
 private:
   friend class SVal;
-  LazyCompoundVal() {}
+  LazyCompoundVal();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == LazyCompoundValKind;
   }
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == LazyCompoundValKind;
   }
 };
 
 } // end namespace ento::nonloc
 
 //==------------------------------------------------------------------------==//
 //  Subclasses of Loc.
 //==------------------------------------------------------------------------==//
 
 namespace loc {
 
 enum Kind {
 #define LOC_SVAL(Id, Parent) Id ## Kind,
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.def"
 };
 
 class GotoLabel : public Loc {
 public:
-  explicit GotoLabel(LabelDecl *Label) : Loc(GotoLabelKind, Label) {}
+  explicit GotoLabel(LabelDecl *Label);
 
   const LabelDecl *getLabel() const {
     return static_cast<const LabelDecl*>(Data);
   }
 
 private:
   friend class SVal;
-  GotoLabel() {}
+  GotoLabel();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == LocKind && V.getSubKind() == GotoLabelKind;
   }
 
   static bool isKind(const Loc& V) {
     return V.getSubKind() == GotoLabelKind;
   }
 };
 
 
 class MemRegionVal : public Loc {
 public:
-  explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {}
+  explicit MemRegionVal(const MemRegion* r);
 
   /// \brief Get the underlining region.
   const MemRegion* getRegion() const {
     return static_cast<const MemRegion*>(Data);
   }
 
   /// \brief Get the underlining region and strip casts.
   const MemRegion* stripCasts(bool StripBaseCasts = true) const;
 
   template <typename REGION>
   const REGION* getRegionAs() const {
     return dyn_cast<REGION>(getRegion());
   }
 
   inline bool operator==(const MemRegionVal& R) const {
     return getRegion() == R.getRegion();
   }
 
   inline bool operator!=(const MemRegionVal& R) const {
     return getRegion() != R.getRegion();
   }
 
 private:
   friend class SVal;
-  MemRegionVal() {}
+  MemRegionVal();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == LocKind &&
            V.getSubKind() == MemRegionValKind;
   }
 
   static bool isKind(const Loc& V) {
     return V.getSubKind() == MemRegionValKind;
   }
 };
 
 class ConcreteInt : public Loc {
 public:
-  explicit ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {}
+  explicit ConcreteInt(const llvm::APSInt& V);
 
   const llvm::APSInt& getValue() const {
     return *static_cast<const llvm::APSInt*>(Data);
   }
 
   // Transfer functions for binary/unary operations on ConcreteInts.
   SVal evalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op,
                  const ConcreteInt& R) const;
 
 private:
   friend class SVal;
-  ConcreteInt() {}
+  ConcreteInt();
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == LocKind &&
            V.getSubKind() == ConcreteIntKind;
   }
 
   static bool isKind(const Loc& V) {
     return V.getSubKind() == ConcreteIntKind;
   }

llvm/tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp

void BugReport::pushInterestingSymbolsAndRegions() {
   interestingRegions.push_back(new Regions(getInterestingRegions()));
 }
 
 void BugReport::popInterestingSymbolsAndRegions() {
   delete interestingSymbols.pop_back_val();
   delete interestingRegions.pop_back_val();
 }
 
+BugReport::BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode)
+  : BT(bt), DeclWithIssue(nullptr), Description(desc), ErrorNode(errornode),
+    ConfigurationChangeToken(0), DoNotPrunePath(false) {}
+
+BugReport::BugReport(BugType& bt, StringRef shortDesc, StringRef desc,
+          const ExplodedNode *errornode)
+  : BT(bt), DeclWithIssue(nullptr), ShortDescription(shortDesc),
+    Description(desc), ErrorNode(errornode), ConfigurationChangeToken(0),
+    DoNotPrunePath(false) {}
+
+BugReport::BugReport(BugType &bt, StringRef desc, PathDiagnosticLocation l)
+  : BT(bt), DeclWithIssue(nullptr), Description(desc), Location(l),
+    ErrorNode(nullptr), ConfigurationChangeToken(0), DoNotPrunePath(false) {}
+
+BugReport::BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode,
+          PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique)
+  : BT(bt), DeclWithIssue(nullptr), Description(desc),
+    UniqueingLocation(LocationToUnique),
+    UniqueingDecl(DeclToUnique),
+    ErrorNode(errornode), ConfigurationChangeToken(0),
+    DoNotPrunePath(false) {}
+
+
+
 const Stmt *BugReport::getStmt() const {
   if (!ErrorNode)
     return nullptr;
 
   ProgramPoint ProgP = ErrorNode->getLocation();
   const Stmt *S = nullptr;
 
   if (Optional<BlockEntrance> BE = ProgP.getAs<BlockEntrance>()) {

llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp

CheckerManager::getCachedStmtCheckersFor(const Stmt *S, bool isPreVisit) {
   for (unsigned i = 0, e = StmtCheckers.size(); i != e; ++i) {
     StmtCheckerInfo &Info = StmtCheckers[i];
     if (Info.IsPreVisit == isPreVisit && Info.IsForStmtFn(S))
       Checkers.push_back(Info.CheckFn);
   }
   return Checkers;
 }
 
+CheckerManager::CheckerManager(const LangOptions &langOpts,
+                               AnalyzerOptionsRef AOptions)
+  : LangOpts(langOpts),
+    AOptions(AOptions) {}
+
+
 CheckerManager::~CheckerManager() {
   for (unsigned i = 0, e = CheckerDtors.size(); i != e; ++i)
     CheckerDtors[i]();
 }

llvm/tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp

 
 WorkList* WorkList::makeBFSBlockDFSContents() {
   return new BFSBlockDFSContents();
 }
 
 //===----------------------------------------------------------------------===//
 // Core analysis engine.
 //===----------------------------------------------------------------------===//
+CoreEngine::CoreEngine(SubEngine &subengine, FunctionSummariesTy *FS)
+    : SubEng(subengine), WList(WorkList::makeDFS()),
+      BCounterFactory(G.getAllocator()), FunctionSummaries(FS) {}
 
 /// ExecuteWorkList - Run the worklist algorithm for a maximum number of steps.
 bool CoreEngine::ExecuteWorkList(const LocationContext *L, unsigned Steps,
                                    ProgramStateRef InitState) {
 
   if (G.num_roots() == 0) { // Initialize the analysis by constructing
     // the root if none exists.
 
if (N->getLocationContext()->getParent()) {
       NumPathsExplored++;
     }
   }
 }
 
 
 void NodeBuilder::anchor() { }
 
+void NodeBuilder::finalizeResults() {}
+
+NodeBuilder::NodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
+            const NodeBuilderContext &Ctx, bool F)
+   : C(Ctx), Finalized(F), HasGeneratedNodes(false), Frontier(DstSet) {
+  Frontier.Add(SrcNode);
+}
+
+NodeBuilder::NodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
+            const NodeBuilderContext &Ctx, bool F)
+  : C(Ctx), Finalized(F), HasGeneratedNodes(false), Frontier(DstSet) {
+  Frontier.insert(SrcSet);
+  assert(hasNoSinksInFrontier());
+}
+
+NodeBuilder::~NodeBuilder() {}
+
 ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
                                             ProgramStateRef State,
                                             ExplodedNode *FromN,
                                             bool MarkAsSink) {
   HasGeneratedNodes = true;
   bool IsNew;
   ExplodedNode *N = C.Eng.G.getNode(Loc, State, MarkAsSink, &IsNew);
   N->addPredecessor(FromN, C.Eng.G);
   Frontier.erase(FromN);
 
   if (!IsNew)
     return nullptr;
 
   if (!MarkAsSink)
     Frontier.Add(N);
 
   return N;
 }
 
 void NodeBuilderWithSinks::anchor() { }
 
+NodeBuilderWithSinks::NodeBuilderWithSinks(ExplodedNode *Pred, ExplodedNodeSet &DstSet,
+                     const NodeBuilderContext &Ctx, ProgramPoint &L)
+  : NodeBuilder(Pred, DstSet, Ctx), Location(L) {}
+
+StmtNodeBuilder::StmtNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
+                const NodeBuilderContext &Ctx,
+                NodeBuilder *Enclosing)
+  : NodeBuilder(SrcNode, DstSet, Ctx), EnclosingBldr(Enclosing) {
+  if (EnclosingBldr)
+    EnclosingBldr->takeNodes(SrcNode);
+}
+
+StmtNodeBuilder::StmtNodeBuilder(ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
+                const NodeBuilderContext &Ctx,
+                NodeBuilder *Enclosing)
+  : NodeBuilder(SrcSet, DstSet, Ctx), EnclosingBldr(Enclosing) {
+  if (EnclosingBldr)
+    for (ExplodedNodeSet::iterator I = SrcSet.begin(),
+                                   E = SrcSet.end(); I != E; ++I )
+      EnclosingBldr->takeNodes(*I);
+}
+
 StmtNodeBuilder::~StmtNodeBuilder() {
   if (EnclosingBldr)
     for (ExplodedNodeSet::iterator I = Frontier.begin(),
                                    E = Frontier.end(); I != E; ++I )
       EnclosingBldr->addNodes(*I);
 }
 
 void BranchNodeBuilder::anchor() { }
 
+BranchNodeBuilder::BranchNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
+                  const NodeBuilderContext &C,
+                  const CFGBlock *dstT, const CFGBlock *dstF)
+: NodeBuilder(SrcNode, DstSet, C), DstT(dstT), DstF(dstF),
+  InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
+  // The branch node builder does not generate autotransitions.
+  // If there are no successors it means that both branches are infeasible.
+  takeNodes(SrcNode);
+}
+
+BranchNodeBuilder::BranchNodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
+                  const NodeBuilderContext &C,
+                  const CFGBlock *dstT, const CFGBlock *dstF)
+: NodeBuilder(SrcSet, DstSet, C), DstT(dstT), DstF(dstF),
+  InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
+  takeNodes(SrcSet);
+}
+
+
 ExplodedNode *BranchNodeBuilder::generateNode(ProgramStateRef State,
                                               bool branch,
                                               ExplodedNode *NodePred) {
   // If the branch has been marked infeasible we should not generate a node.
   if (!isFeasible(branch))
     return nullptr;
 
   ProgramPoint Loc = BlockEdge(C.Block, branch ? DstT:DstF,
                                NodePred->getLocationContext());
   ExplodedNode *Succ = generateNodeImpl(Loc, State, NodePred);
   return Succ;
 }
 
+IndirectGotoNodeBuilder::IndirectGotoNodeBuilder(ExplodedNode *pred, const CFGBlock *src, 
+                  const Expr *e, const CFGBlock *dispatch, CoreEngine* eng)
+  : Eng(*eng), Src(src), DispatchBlock(*dispatch), E(e), Pred(pred) {}
+
+
 ExplodedNode*
 IndirectGotoNodeBuilder::generateNode(const iterator &I,
                                       ProgramStateRef St,
                                       bool IsSink) {
   bool IsNew;
   ExplodedNode *Succ =
       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
                     St, IsSink, &IsNew);
   Succ->addPredecessor(Pred, Eng.G);
 
   if (!IsNew)
     return nullptr;
 
   if (!IsSink)
     Eng.WList->enqueue(Succ);
 
   return Succ;
 }
 
+SwitchNodeBuilder::SwitchNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
+                  const Expr *condition, CoreEngine* eng)
+: Eng(*eng), Src(src), Condition(condition), Pred(pred) {}
+
 
 ExplodedNode*
 SwitchNodeBuilder::generateCaseStmtNode(const iterator &I,
                                         ProgramStateRef St) {
 
   bool IsNew;
   ExplodedNode *Succ =
       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
SwitchNodeBuilder::generateDefaultCaseNode(ProgramStateRef St,
   if (!IsNew)
     return nullptr;
 
   if (!IsSink)
     Eng.WList->enqueue(Succ);
 
   return Succ;
 }
+
+NodeBuilderContext::NodeBuilderContext(const CoreEngine &E, const CFGBlock *B, ExplodedNode *N)
+  : Eng(E), Block(B), LC(N->getLocationContext()) { assert(B); }

llvm/tools/clang/lib/StaticAnalyzer/Core/SVals.cpp

if (Optional<nonloc::ConcreteInt> NV = getAs<nonloc::ConcreteInt>())
     return NV->getValue() == I;
   return false;
 }
 
 bool SVal::isZeroConstant() const {
   return isConstant(0);
 }
 
+//===----------------------------------------------------------------------===//
+// Previously inlined functions.
+//===----------------------------------------------------------------------===//
+
+DefinedSVal::DefinedSVal() {}
+
+DefinedSVal::DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
+  : DefinedOrUnknownSVal(d, isLoc, ValKind) {}
+
+KnownSVal::KnownSVal() {}
+
+KnownSVal::KnownSVal(const DefinedSVal &V) : SVal(V) {}
+
+KnownSVal::KnownSVal(const UndefinedVal &V) : SVal(V) {}
+
+NonLoc::NonLoc() {}
+
+NonLoc::NonLoc(unsigned SubKind, const void *d)
+  : DefinedSVal(d, false, SubKind) {}
+
+Loc::Loc() {}
+
+Loc::Loc(unsigned SubKind, const void *D)
+  : DefinedSVal(D, true, SubKind) {}
+
+bool Loc::isLocType(QualType T) {
+  return T->isAnyPointerType() || T->isBlockPointerType() || 
+         T->isReferenceType() || T->isNullPtrType();
+}
+
+nonloc::SymbolVal::SymbolVal(SymbolRef sym) : NonLoc(SymbolValKind, sym) {}
+
+nonloc::SymbolVal::SymbolVal() {}
+
+nonloc::ConcreteInt::ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {}
+
+nonloc::ConcreteInt::ConcreteInt() {}
+
+nonloc::LocAsInteger::LocAsInteger(const std::pair<SVal, uintptr_t> &data)
+    : NonLoc(LocAsIntegerKind, &data) {
+  assert (data.first.getAs<Loc>());
+}
+
+nonloc::LocAsInteger::LocAsInteger() {}
+
+nonloc::CompoundVal::CompoundVal(const CompoundValData* D) 
+  : NonLoc(CompoundValKind, D) {}
+
+nonloc::CompoundVal::CompoundVal() {}
+
+nonloc::LazyCompoundVal::LazyCompoundVal(const LazyCompoundValData *D)
+  : NonLoc(LazyCompoundValKind, D) {}
+
+nonloc::LazyCompoundVal::LazyCompoundVal() {}
+
+loc::GotoLabel::GotoLabel(LabelDecl *Label) : Loc(GotoLabelKind, Label) {}
+
+loc::GotoLabel::GotoLabel() {}
+
+
+loc::MemRegionVal::MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {}
+
+loc::MemRegionVal::MemRegionVal() {}
+
+
+loc::ConcreteInt::ConcreteInt(const llvm::APSInt& V)
+  : Loc(ConcreteIntKind, &V) {}
+
+loc::ConcreteInt::ConcreteInt() {}
 
 //===----------------------------------------------------------------------===//
 // Transfer function dispatch for Non-Locs.
 //===----------------------------------------------------------------------===//
 
 SVal nonloc::ConcreteInt::evalBinOp(SValBuilder &svalBuilder,
                                     BinaryOperator::Opcode Op,
                                     const nonloc::ConcreteInt& R) const {