svf-tools 1.0.1091 → 1.0.1092

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1091",
+  "version": "1.0.1092",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/Graphs/SVFGOPT.h

@@ -81,9 +81,18 @@ public:
         keepContextSelfCycle = true;
     }
 
+    /// Optimised SVFG's aren't written in their optimised form; read full SVFG and optimise it
+    void readAndOptSVFG(const std::string &filename);
+
+    /// Optimised SVFG's shouldn't be written in their optimised form; writes the full SVFG to file before optimising
+    void buildAndWriteSVFG(const std::string &filename);
+
 protected:
     void buildSVFG() override;
 
+    /// Separate optimisation function to avoid duplicate code
+    void optimiseSVFG();
+
     /// Connect SVFG nodes between caller and callee for indirect call sites
     //@{
     inline void connectAParamAndFParam(const PAGNode* cs_arg, const PAGNode* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges) override

package/svf/include/Graphs/VFG.h

@@ -191,9 +191,70 @@ public:
         return getVFGNode(getDef(pagNode));
     }
 
+    // Given an VFG node, return true if it has a left hand side top level pointer (PAGnode)
+    inline bool hasLHSTopLevPtr(const VFGNode* node) const {
+        return node && SVFUtil::isa<AddrVFGNode,
+                                    CopyVFGNode,
+                                    GepVFGNode,
+                                    LoadVFGNode,
+                                    PHIVFGNode,
+                                    CmpVFGNode,
+                                    BinaryOPVFGNode,
+                                    UnaryOPVFGNode,
+                                    ActualParmVFGNode,
+                                    FormalParmVFGNode,
+                                    ActualRetVFGNode,
+                                    FormalRetVFGNode,
+                                    NullPtrVFGNode>(node);
+    }
+
     // Given an VFG node, return its left hand side top level pointer (PAGnode)
     const PAGNode* getLHSTopLevPtr(const VFGNode* node) const;
 
+    /// Existence checks for VFGNodes
+    //@{
+    inline bool hasStmtVFGNode(const PAGEdge* pagEdge) const
+    {
+        return PAGEdgeToStmtVFGNodeMap.find(pagEdge) != PAGEdgeToStmtVFGNodeMap.end();
+    }
+    inline bool hasIntraPHIVFGNode(const PAGNode* pagNode) const
+    {
+        return PAGNodeToIntraPHIVFGNodeMap.find(pagNode) != PAGNodeToIntraPHIVFGNodeMap.end();
+    }
+    inline bool hasBinaryOPVFGNode(const PAGNode* pagNode) const
+    {
+        return PAGNodeToBinaryOPVFGNodeMap.find(pagNode) != PAGNodeToBinaryOPVFGNodeMap.end();
+    }
+    inline bool hasUnaryOPVFGNode(const PAGNode* pagNode) const
+    {
+        return PAGNodeToUnaryOPVFGNodeMap.find(pagNode) != PAGNodeToUnaryOPVFGNodeMap.end();
+    }
+    inline bool hasBranchVFGNode(const PAGNode* pagNode) const
+    {
+        return PAGNodeToBranchVFGNodeMap.find(pagNode) != PAGNodeToBranchVFGNodeMap.end();
+    }
+    inline bool hasCmpVFGNode(const PAGNode* pagNode) const
+    {
+        return PAGNodeToCmpVFGNodeMap.find(pagNode) != PAGNodeToCmpVFGNodeMap.end();
+    }
+    inline bool hasActualParmVFGNode(const PAGNode* aparm,const CallICFGNode* cs) const
+    {
+        return PAGNodeToActualParmMap.find(std::make_pair(aparm->getId(),cs)) != PAGNodeToActualParmMap.end();
+    }
+    inline bool hasActualRetVFGNode(const PAGNode* aret) const
+    {
+        return PAGNodeToActualRetMap.find(aret) != PAGNodeToActualRetMap.end();
+    }
+    inline bool hasFormalParmVFGNode(const PAGNode* fparm) const
+    {
+        return PAGNodeToFormalParmMap.find(fparm) != PAGNodeToFormalParmMap.end();
+    }
+    inline bool hasFormalRetVFGNode(const PAGNode* fret) const
+    {
+        return PAGNodeToFormalRetMap.find(fret) != PAGNodeToFormalRetMap.end();
+    }
+    //@}
+
     /// Get an VFGNode
     //@{
     inline StmtVFGNode* getStmtVFGNode(const PAGEdge* pagEdge) const

package/svf/include/MSSA/SVFGBuilder.h

@@ -32,6 +32,7 @@
 
 #include "MemoryModel/PointerAnalysis.h"
 #include "Graphs/SVFGOPT.h"
+#include "Util/Options.h"
 
 namespace SVF
 {
@@ -49,7 +50,10 @@ public:
     typedef SVFG::SVFGEdgeSetTy SVFGEdgeSet;
 
     /// Constructor
-    explicit SVFGBuilder(bool _SVFGWithIndCall = false): svfg(nullptr), SVFGWithIndCall(_SVFGWithIndCall) {}
+    explicit SVFGBuilder(bool _SVFGWithIndCall = Options::SVFGWithIndirectCall(), bool _SVFGWithPostOpts = Options::OPTSVFG())
+        : svfg(nullptr), SVFGWithIndCall(_SVFGWithIndCall), SVFGWithPostOpts(_SVFGWithPostOpts)
+    {
+    }
 
     /// Destructor
     virtual ~SVFGBuilder() = default;
@@ -91,6 +95,8 @@ protected:
     std::unique_ptr<SVFG> svfg;
     /// SVFG with precomputed indirect call edges
     bool SVFGWithIndCall;
+    /// Build optimised version of SVFG
+    bool SVFGWithPostOpts;
 };
 
 } // End namespace SVF

package/svf/include/WPA/VersionedFlowSensitive.h

@@ -110,6 +110,45 @@ protected:
     /// Override since we want to assign different weights based on versioning.
     virtual void cluster(void) override;
 
+public:
+    /// Returns true if l is a store node.
+    virtual bool isStore(const NodeID l) const;
+
+    /// Returns true if l is a load node.
+    virtual bool isLoad(const NodeID l) const;
+
+    /// Shared code for getConsume and getYield. They wrap this function.
+    Version getVersion(const NodeID l, const NodeID o, const LocVersionMap &lvm) const;
+
+    /// Returns the consumed version of o at l. If no such version exists, returns invalidVersion.
+    Version getConsume(const NodeID l, const NodeID o) const;
+
+    /// Returns the yielded version of o at l. If no such version exists, returns invalidVersion.
+    Version getYield(const NodeID l, const NodeID o) const;
+
+    /// Returns the versions of o which rely on o:v.
+    std::vector<Version> &getReliantVersions(const NodeID o, const Version v);
+
+    /// Returns the statements which rely on o:v.
+    NodeBS &getStmtReliance(const NodeID o, const Version v);
+
+    /// Dumps versionReliance and stmtReliance.
+    void dumpReliances(void) const;
+
+    /// Dumps maps consume and yield.
+    void dumpLocVersionMaps(void) const;
+
+    void solveAndwritePtsToFile(const std::string& filename) override;
+
+    void writeVersionedAnalysisResultToFile(const std::string& filename);
+
+    void readVersionedAnalysisResultFromFile(std::ifstream& F);
+
+    void readPtsFromFile(const std::string& filename) override;
+
+    /// Dumps a MeldVersion to stdout.
+    static void dumpMeldVersion(MeldVersion &v);
+
 private:
     /// Prelabel the SVFG: set y(o) for stores and c(o) for delta nodes to a new version.
     void prelabel(void);
@@ -133,12 +172,6 @@ private:
     /// Fills in isStoreMap and isLoadMap.
     virtual void buildIsStoreLoadMaps(void);
 
-    /// Returns true if l is a store node.
-    virtual bool isStore(const NodeID l) const;
-
-    /// Returns true if l is a load node.
-    virtual bool isLoad(const NodeID l) const;
-
     /// Fills in deltaMap and deltaSourceMap for the SVFG.
     virtual void buildDeltaMaps(void);
 
@@ -150,15 +183,6 @@ private:
     /// edge to a delta node due to on-the-fly callgraph construction.
     virtual bool deltaSource(const NodeID l) const;
 
-    /// Shared code for getConsume and getYield. They wrap this function.
-    Version getVersion(const NodeID l, const NodeID o, const LocVersionMap &lvm) const;
-
-    /// Returns the consumed version of o at l. If no such version exists, returns invalidVersion.
-    Version getConsume(const NodeID l, const NodeID o) const;
-
-    /// Returns the yielded version of o at l. If no such version exists, returns invalidVersion.
-    Version getYield(const NodeID l, const NodeID o) const;
-
     /// Shared code for setConsume and setYield. They wrap this function.
     void setVersion(const NodeID l, const NodeID o, const Version v, LocVersionMap &lvm);
 
@@ -168,29 +192,6 @@ private:
     /// Sets the yielded version of o at l to v.
     void setYield(const NodeID l, const NodeID o, const Version v);
 
-    /// Returns the versions of o which rely on o:v.
-    std::vector<Version> &getReliantVersions(const NodeID o, const Version v);
-
-    /// Returns the statements which rely on o:v.
-    NodeBS &getStmtReliance(const NodeID o, const Version v);
-
-    /// Dumps versionReliance and stmtReliance.
-    void dumpReliances(void) const;
-
-    /// Dumps maps consume and yield.
-    void dumpLocVersionMaps(void) const;
-
-    void solveAndwritePtsToFile(const std::string& filename) override;
-
-    void writeVersionedAnalysisResultToFile(const std::string& filename);
-
-    void readVersionedAnalysisResultFromFile(std::ifstream& F);
-
-    void readPtsFromFile(const std::string& filename) override;
-
-    /// Dumps a MeldVersion to stdout.
-    static void dumpMeldVersion(MeldVersion &v);
-
     /// Maps locations to objects to a version. The object version is what is
     /// consumed at that location.
     LocVersionMap consume;

package/svf/lib/Graphs/SVFGOPT.cpp

@@ -43,11 +43,29 @@ static std::string KeepAllSelfCycle = "all";
 static std::string KeepContextSelfCycle = "context";
 static std::string KeepNoneSelfCycle = "none";
 
+/// Optimised SVFGs aren't written to file; reads the full SVFG and optimises it
+void SVFGOPT::readAndOptSVFG(const std::string &filename)
+{
+    SVFG::readFile(filename);
+    optimiseSVFG();
+}
+
+/// Shouldn't write optimised SVFG to file; writes the built SVFG to file before optimisation
+void SVFGOPT::buildAndWriteSVFG(const std::string &filename)
+{
+    SVFG::buildSVFG();
+    SVFG::writeToFile(filename);
+    optimiseSVFG();
+}
 
 void SVFGOPT::buildSVFG()
 {
     SVFG::buildSVFG();
+    optimiseSVFG();
+}
 
+/// Separate function to optimise the SVFG to avoid duplicate code
+void SVFGOPT::optimiseSVFG() {
     if(Options::DumpVFG())
         dump("SVFG_before_opt");
 
@@ -62,6 +80,7 @@ void SVFGOPT::buildSVFG()
     stat->sfvgOptEnd();
 
 }
+
 /*!
  *
  */

package/svf/lib/MSSA/SVFGBuilder.cpp

@@ -26,33 +26,29 @@
  *  Created on: Apr 15, 2014
  *      Author: Yulei Sui
  */
+#include "MSSA/SVFGBuilder.h"
+#include "Graphs/CallGraph.h"
+#include "Graphs/SVFG.h"
+#include "MSSA/MemSSA.h"
 #include "Util/Options.h"
 #include "Util/SVFUtil.h"
-#include "MSSA/MemSSA.h"
-#include "Graphs/SVFG.h"
-#include "MSSA/SVFGBuilder.h"
 #include "WPA/Andersen.h"
-#include "Graphs/CallGraph.h"
-
 
 using namespace SVF;
 using namespace SVFUtil;
 
-
 SVFG* SVFGBuilder::buildPTROnlySVFG(BVDataPTAImpl* pta)
 {
-    if(Options::OPTSVFG())
-        return build(pta, VFG::PTRONLYSVFG_OPT);
-    else
-        return build(pta, VFG::PTRONLYSVFG);
+    return this->SVFGWithPostOpts ? build(pta, VFG::PTRONLYSVFG_OPT)
+                                  : build(pta, VFG::PTRONLYSVFG);
 }
 
 SVFG* SVFGBuilder::buildFullSVFG(BVDataPTAImpl* pta)
 {
-    return build(pta, VFG::FULLSVFG);
+    return this->SVFGWithPostOpts ? build(pta, VFG::FULLSVFG_OPT)
+                                  : build(pta, VFG::FULLSVFG);
 }
 
-
 /*!
  * Create SVFG
  */
@@ -65,23 +61,24 @@ void SVFGBuilder::buildSVFG()
 SVFG* SVFGBuilder::build(BVDataPTAImpl* pta, VFG::VFGK kind)
 {
 
-    auto mssa = buildMSSA(pta, (VFG::PTRONLYSVFG==kind || VFG::PTRONLYSVFG_OPT==kind));
+    auto mssa = buildMSSA(
+        pta, (VFG::PTRONLYSVFG == kind || VFG::PTRONLYSVFG_OPT == kind));
 
     DBOUT(DGENERAL, outs() << pasMsg("Build Sparse Value-Flow Graph \n"));
-    if(kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
+    if (kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
         svfg = std::make_unique<SVFGOPT>(std::move(mssa), kind);
     else
-        svfg = std::unique_ptr<SVFG>(new SVFG(std::move(mssa),kind));
+        svfg = std::unique_ptr<SVFG>(new SVFG(std::move(mssa), kind));
     buildSVFG();
 
     /// Update call graph using pre-analysis results
-    if(Options::SVFGWithIndirectCall() || SVFGWithIndCall)
+    if (SVFGWithIndCall)
         svfg->updateCallGraph(pta);
 
-    if(svfg->getMSSA()->getPTA()->printStat())
+    if (svfg->getMSSA()->getPTA()->printStat())
         svfg->performStat();
 
-    if(Options::DumpVFG())
+    if (Options::DumpVFG())
         svfg->dump("svfg_final");
 
     return svfg.get();
@@ -95,7 +92,8 @@ void SVFGBuilder::releaseMemory()
     svfg->clearMSSA();
 }
 
-std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyMSSA)
+std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta,
+                                               bool ptrOnlyMSSA)
 {
 
     DBOUT(DGENERAL, outs() << pasMsg("Build Memory SSA \n"));
@@ -103,10 +101,10 @@ std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyM
     auto mssa = std::make_unique<MemSSA>(pta, ptrOnlyMSSA);
 
     CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
-    for (const auto& item: *svfirCallGraph)
+    for (const auto& item : *svfirCallGraph)
     {
 
-        const FunObjVar *fun = item.second->getFunction();
+        const FunObjVar* fun = item.second->getFunction();
         if (isExtCall(fun))
             continue;
 
@@ -121,5 +119,3 @@ std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyM
 
     return mssa;
 }
-
-

package/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -250,6 +250,11 @@ public:
         addToSVFVar2LLVMValueMap(inst, svfInst);
     }
 
+    inline bool hasLLVMValue(const SVFValue* value) const
+    {
+        return SVFBaseNode2LLVMValue.find(value) != SVFBaseNode2LLVMValue.end();
+    }
+
     const Value* getLLVMValue(const SVFValue* value) const
     {
         SVFBaseNode2LLVMValueMap ::const_iterator it = SVFBaseNode2LLVMValue.find(value);

package/svf-llvm/lib/extapi.c

@@ -1,5 +1,9 @@
 #include <stddef.h>
-#define NULL ((void *)0)
+
+// Ensure NULL is always defined (but don't redefine)
+#ifndef NULL
+#  define NULL ((void *)0)
+#endif
 
 /*
     Functions with __attribute__((annotate("XXX"))) will be handle by SVF specifcially.
@@ -189,24 +193,6 @@ void* xmalloc(unsigned long size)
     return NULL;
 }
 
-__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
-void *_Znam(unsigned long size)
-{
-    return NULL;
-}
-
-__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
-void *_Znaj(unsigned long size)
-{
-    return NULL;
-}
-
-__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
-void *_Znwj(unsigned long size)
-{
-    return NULL;
-}
-
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
 void *__cxa_allocate_exception(unsigned long size)
 {
@@ -231,6 +217,12 @@ void *valloc(unsigned long size)
     return NULL;
 }
 
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *pvalloc(unsigned long size)
+{
+    return NULL;
+}
+
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg1")))
 void *mmap64(void *addr, unsigned long len, int prot, int flags, int fildes, long off)
 {
@@ -369,6 +361,12 @@ char *strdup(const char *s)
     return NULL;
 }
 
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
+char *strndup(const char *s, unsigned long n)
+{
+    return NULL;
+}
+
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
 char *strerror(int errnum)
 {
@@ -429,6 +427,12 @@ char *realloc(void *ptr, unsigned long size)
     return NULL;
 }
 
+__attribute__((annotate("REALLOC_HEAP_RET"), annotate("AllocSize:Arg1*Arg2")))
+char *reallocarray(void *ptr, unsigned long elems, unsigned long size)
+{
+    return NULL;
+}
+
 __attribute__((annotate("REALLOC_HEAP_RET"), annotate("AllocSize:Arg1")))
 void* safe_realloc(void *p, unsigned long n)
 {
@@ -469,26 +473,120 @@ void *xrealloc(void *ptr, unsigned long bytes)
     return NULL;
 }
 
+// ::operator new (size (unsigned int))
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_Znwj(unsigned int size)
+{
+    return NULL;
+}
+
+// ::operator new (size (unsigned int), nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnwjRKSt9nothrow_t(unsigned int size, void *)
+{
+    return NULL;
+}
+
+// ::operator new (size (unsigned int), aligned)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnwjSt11align_val_t(unsigned int size, unsigned long)
+{
+    return NULL;
+}
+
+// ::operator new (size (unsigned int), aligned, nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnwjSt11align_val_tRKSt9nothrow_t(unsigned int size, unsigned long, void *)
+{
+    return NULL;
+}
+
+// ::operator new[] (size (unsigned int))
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_Znaj(unsigned int size)
+{
+    return NULL;
+}
+
+// ::operator new[] (size (unsigned int), nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnajRKSt9nothrow_t(unsigned int size, void *)
+{
+    return NULL;
+}
+
+// ::operator new[] (size (unsigned int), aligned)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnajSt11align_val_t(unsigned int size, unsigned long)
+{
+    return NULL;
+}
+
+// ::operator new[] (size (unsigned int), aligned, nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnajSt11align_val_tRKSt9nothrow_t(unsigned int size, unsigned long, void *)
+{
+    return NULL;
+}
+
+// ::operator new (size (size_t))
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
 void *_Znwm(unsigned long size)
 {
     return NULL;
 }
 
+// ::operator new (size (size_t), nothrow)
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
 void *_ZnwmRKSt9nothrow_t(unsigned long size, void *)
 {
     return NULL;
 }
 
+// ::operator new (size (size_t), aligned)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnwmSt11align_val_t(unsigned long size, unsigned long)
+{
+    return NULL;
+}
+
+// ::operator new (size (size_t), aligned, nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnwmSt11align_val_tRKSt9nothrow_t(unsigned long size, unsigned long, void *)
+{
+    return NULL;
+}
+
+// ::operator new[]
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_Znam(unsigned long size)
+{
+    return NULL;
+}
+
+// ::operator new[] (nothrow)
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
 void *_ZnamRKSt9nothrow_t(unsigned long size, void *)
 {
     return NULL;
 }
 
+// ::operator new[] (aligned)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnamSt11align_val_t(unsigned long size, unsigned long)
+{
+    return NULL;
+}
+
+// ::operator new[] (aligned, nothrow)
+__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
+void *_ZnamSt11align_val_tRKSt9nothrow_t(unsigned long size, unsigned long, void *)
+{
+    return NULL;
+}
+
 __attribute__((annotate("ALLOC_HEAP_ARG0"), annotate("AllocSize:UNKNOWN")))
-int asprintf(char **restrict strp, const char *restrict fmt, ...)
+int asprintf(char **__restrict strp, const char *__restrict fmt, ...)
 {
     return 0;
 }
@@ -536,7 +634,7 @@ int posix_memalign(void **a, unsigned long b, unsigned long c)
 }
 
 __attribute__((annotate("ALLOC_HEAP_ARG1"), annotate("AllocSize:UNKNOWN")))
-int scandir(const char *restrict dirp, struct dirent ***restrict namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
+int scandir(const char *__restrict dirp, struct dirent ***__restrict namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
 {
     return 0;
 }
@@ -590,7 +688,7 @@ __attribute__((annotate("MEMCPY")))
 void bcopy(const void *s1, void *s2, unsigned long n){}
 
 __attribute__((annotate("MEMCPY")))
-void *memccpy( void * restrict dest, const void * restrict src, int c, unsigned long count)
+void *memccpy( void *__restrict dest, const void *__restrict src, int c, unsigned long count)
 {
     return NULL;
 }
@@ -644,7 +742,7 @@ wchar_t* __wcscat_chk(wchar_t * dest, const wchar_t * src)
 }
 
 __attribute__((annotate("STRCPY")))
-char *stpcpy(char *restrict dst, const char *restrict src)
+char *stpcpy(char *__restrict dst, const char *__restrict src)
 {
     return NULL;
 }
@@ -702,7 +800,7 @@ char *wcscpy(wchar_t* dest, const wchar_t* src) {
 }
 
 __attribute__((annotate("MEMCPY")))
-unsigned long iconv(void* cd, char **restrict inbuf, unsigned long *restrict inbytesleft, char **restrict outbuf, unsigned long *restrict outbytesleft)
+unsigned long iconv(void* cd, char **__restrict inbuf, unsigned long *__restrict inbytesleft, char **__restrict outbuf, unsigned long *__restrict outbytesleft)
 {
     return 0;
 }
@@ -906,7 +1004,7 @@ struct tm *localtime_r(const void *timep, struct tm *result)
     return result;
 }
 
-char *realpath(const char *restrict path, char *restrict resolved_path)
+char *realpath(const char *__restrict path, char *__restrict resolved_path)
 {
     return resolved_path;
 }
@@ -921,7 +1019,7 @@ void* freopen(const char* voidname, const char* mode, void* fp)
     return fp;
 }
 
-const char *inet_ntop(int af, const void *restrict src,  char *restrict dst, unsigned int size)
+const char *inet_ntop(int af, const void *__restrict src,  char *__restrict dst, unsigned int size)
 {
     return dst;
 }
@@ -995,9 +1093,9 @@ char* ctime_r(const char *timer, char *buf)
     return buf;
 }
 
-int readdir_r(void *__restrict__dir, void *__restrict__entry, void **__restrict__result)
+int readdir_r(void *__restrict dir, void *__restrict entry, void **__restrict result)
 {
-    __restrict__entry = *__restrict__result;   
+    entry = *result;
     return 0;
 }
 
@@ -1048,13 +1146,13 @@ const unsigned short **__ctype_b_loc(void)
 int ctype_tolower_loc_global[10];
 int **__ctype_tolower_loc(void)
 {
-    return &ctype_tolower_loc_global;
+    return (int **)&ctype_tolower_loc_global;
 }
 
 int ctype_toupper_loc_global[10];
 int **__ctype_toupper_loc(void)
 {
-    return &ctype_toupper_loc_global;
+    return (int **)&ctype_toupper_loc_global;
 }
 
 int error_global[10];
@@ -1075,7 +1173,7 @@ void* __res_state(void)
     return res_state_global;
 }
 
-void *time_global[10];
+char time_global[10];
 char *asctime(const void *timeptr)
 {
     return time_global;