[analyzer] [testing] Pass through an extra argument for specifying extra analyzer options

[NoQ]

LGTM.

utils/analyzer/SATestBuild.py

try:
                    stdout=PBuildLogFile,
                    shell=True)
     except:
         Local.stderr.write("Error: Patch failed. See %s for details.\n" % (
             PBuildLogFile.name))
         sys.exit(1)
 
 
-def runScanBuild(Dir, SBOutputDir, PBuildLogFile):
+def runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile):
     """
     Build the project with scan-build by reading in the commands and
     prefixing them with the scan-build options.
     """
     BuildScriptPath = os.path.join(Dir, BuildScript)
     if not os.path.exists(BuildScriptPath):
         Local.stderr.write(
             "Error: build script is not defined: %s\n" % BuildScriptPath)
def runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile):
     SBOptions = "--use-analyzer '%s' " % Clang
     SBOptions += "-plist-html -o '%s' " % SBOutputDir
     SBOptions += "-enable-checker " + AllCheckers + " "
     SBOptions += "--keep-empty "
     AnalyzerConfig = [
         ("stable-report-filename", "true"),
         ("serialize-stats", "true"),
     ]
-
-    SBOptions += "-analyzer-config '%s' " % (
-        ",".join("%s=%s" % (key, value) for (key, value) in AnalyzerConfig))
+    AnalyzerConfigSerialized = ",".join(
+        "%s=%s" % (key, value) for (key, value) in AnalyzerConfig)
+    if Args.extra_args:
+        AnalyzerConfigSerialized += "," + Args.extra_args
+    SBOptions += "-analyzer-config '%s' " % AnalyzerConfigSerialized
 
     # Always use ccc-analyze to ensure that we can locate the failures
     # directory.
     SBOptions += "--override-compiler "
     ExtraEnv = {}
     try:
         SBCommandFile = open(BuildScriptPath, "r")
         SBPrefix = "scan-build " + SBOptions + " "
def removeLogFile(SBOutputDir):
     # Clean up the log file.
     if (os.path.exists(BuildLogPath)):
         RmCommand = "rm '%s'" % BuildLogPath
         if Verbose == 1:
             Local.stdout.write("  Executing: %s\n" % (RmCommand,))
         check_call(RmCommand, shell=True)
 
 
-def buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild):
+def buildProject(Args, Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild):
     TBegin = time.time()
 
     BuildLogPath = getBuildLogPath(SBOutputDir)
     Local.stdout.write("Log file: %s\n" % (BuildLogPath,))
     Local.stdout.write("Output directory: %s\n" % (SBOutputDir, ))
 
     removeLogFile(SBOutputDir)
 
     # Clean up scan build results.
     if (os.path.exists(SBOutputDir)):
         RmCommand = "rm -r '%s'" % SBOutputDir
         if Verbose == 1:
             Local.stdout.write("  Executing: %s\n" % (RmCommand,))
             check_call(RmCommand, shell=True, stdout=Local.stdout,
                        stderr=Local.stderr)
     assert(not os.path.exists(SBOutputDir))
     os.makedirs(os.path.join(SBOutputDir, LogFolderName))
 
     # Build and analyze the project.
     with open(BuildLogPath, "wb+") as PBuildLogFile:
         if (ProjectBuildMode == 1):
             downloadAndPatch(Dir, PBuildLogFile)
             runCleanupScript(Dir, PBuildLogFile)
-            runScanBuild(Dir, SBOutputDir, PBuildLogFile)
+            runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile)
         else:
             runAnalyzePreprocessed(Dir, SBOutputDir, ProjectBuildMode)
 
         if IsReferenceBuild:
             runCleanupScript(Dir, PBuildLogFile)
             normalizeReferenceResults(Dir, SBOutputDir, ProjectBuildMode)
 
     Local.stdout.write("Build complete (time: %.2f). "
for E in Extensions:
             RmCommand = "rm '%s'" % P
             check_call(RmCommand, shell=True)
 
     # Remove the log file. It leaks absolute path names.
     removeLogFile(SBOutputDir)
 
 
 class TestProjectThread(threading.Thread):
-    def __init__(self, TasksQueue, ResultsDiffer, FailureFlag):
+    def __init__(self, Args, TasksQueue, ResultsDiffer, FailureFlag):
         """
         :param ResultsDiffer: Used to signify that results differ from
         the canonical ones.
         :param FailureFlag: Used to signify a failure during the run.
         """
+        self.Args = Args
         self.TasksQueue = TasksQueue
         self.ResultsDiffer = ResultsDiffer
         self.FailureFlag = FailureFlag
         super(TestProjectThread, self).__init__()
 
         # Needed to gracefully handle interrupts with Ctrl-C
         self.daemon = True
 
     def run(self):
         while not self.TasksQueue.empty():
             try:
                 ProjArgs = self.TasksQueue.get()
                 Logger = logging.getLogger(ProjArgs[0])
                 Local.stdout = StreamToLogger(Logger, logging.INFO)
                 Local.stderr = StreamToLogger(Logger, logging.ERROR)
-                if not testProject(*ProjArgs):
+                if not testProject(Args, *ProjArgs):
                     self.ResultsDiffer.set()
                 self.TasksQueue.task_done()
             except:
                 self.FailureFlag.set()
                 raise
 
 
-def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Strictness=0):
+def testProject(Args, ID, ProjectBuildMode, IsReferenceBuild=False, Strictness=0):
     """
     Test a given project.
     :return TestsPassed: Whether tests have passed according
     to the :param Strictness: criteria.
     """
     Local.stdout.write(" \n\n--- Building project %s\n" % (ID,))
 
     TBegin = time.time()
 
     Dir = getProjectDir(ID)
     if Verbose == 1:
         Local.stdout.write("  Build directory: %s.\n" % (Dir,))
 
     # Set the build results directory.
     RelOutputDir = getSBOutputDirName(IsReferenceBuild)
     SBOutputDir = os.path.join(Dir, RelOutputDir)
 
-    buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild)
+    buildProject(Args, Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild)
 
     checkBuild(SBOutputDir)
 
     if IsReferenceBuild:
         cleanupReferenceResults(SBOutputDir)
         TestsPassed = True
     else:
         TestsPassed = runCmpResults(Dir, Strictness)
for I in iterateOverProjects(PMapFile):
         if len(I) != 2:
             print "Error: Rows in the ProjectMapFile should have 2 entries."
             raise Exception()
         if I[1] not in ('0', '1', '2'):
             print "Error: Second entry in the ProjectMapFile should be 0" \
                   " (single file), 1 (project), or 2(single file c++11)."
             raise Exception()
 
-def singleThreadedTestAll(ProjectsToTest):
+def singleThreadedTestAll(Args, ProjectsToTest):
     """
     Run all projects.
     :return: whether tests have passed.
     """
     Success = True
     for ProjArgs in ProjectsToTest:
-        Success &= testProject(*ProjArgs)
+        Success &= testProject(Args, *ProjArgs)
     return Success
 
-def multiThreadedTestAll(ProjectsToTest, Jobs):
+def multiThreadedTestAll(Args, ProjectsToTest, Jobs):
     """
     Run each project in a separate thread.
 
     This is OK despite GIL, as testing is blocked
     on launching external processes.
 
     :return: whether tests have passed.
     """
     TasksQueue = Queue.Queue()
 
     for ProjArgs in ProjectsToTest:
         TasksQueue.put(ProjArgs)
 
     ResultsDiffer = threading.Event()
     FailureFlag = threading.Event()
 
     for i in range(Jobs):
-        T = TestProjectThread(TasksQueue, ResultsDiffer, FailureFlag)
+        T = TestProjectThread(Args, TasksQueue, ResultsDiffer, FailureFlag)
         T.start()
 
     # Required to handle Ctrl-C gracefully.
     while TasksQueue.unfinished_tasks:
         time.sleep(0.1)  # Seconds.
         if FailureFlag.is_set():
             Local.stderr.write("Test runner crashed\n")
             sys.exit(1)
     return not ResultsDiffer.is_set()
 
 
 def testAll(Args):
     ProjectsToTest = []
 
     with projectFileHandler() as PMapFile:
         validateProjectFile(PMapFile)
 
         # Test the projects.
         for (ProjName, ProjBuildMode) in iterateOverProjects(PMapFile):
             ProjectsToTest.append((ProjName,
                                   int(ProjBuildMode),
                                   Args.regenerate,
                                   Args.strictness))
     if Args.jobs <= 1:
-        return singleThreadedTestAll(ProjectsToTest)
+        return singleThreadedTestAll(Args, ProjectsToTest)
     else:
-        return multiThreadedTestAll(ProjectsToTest, Args.jobs)
+        return multiThreadedTestAll(Args, ProjectsToTest, Args.jobs)
 
 
 if __name__ == '__main__':
     # Parse command line arguments.
     Parser = argparse.ArgumentParser(
         description='Test the Clang Static Analyzer.')
     Parser.add_argument('--strictness', dest='strictness', type=int, default=0,
                         help='0 to fail on runtime errors, 1 to fail when the \
                              number of found bugs are different from the \
                              reference, 2 to fail on any difference from the \
                              reference. Default is 0.')
     Parser.add_argument('-r', dest='regenerate', action='store_true',
                         default=False, help='Regenerate reference output.')
     Parser.add_argument('-j', '--jobs', dest='jobs', type=int,
                         default=0,
                         help='Number of projects to test concurrently')
+    Parser.add_argument('--extra-analyzer-args', dest='extra_args',
+                        type=str, default="",
+                        help="Extra arguments to add to -analyzer-config")
     Args = Parser.parse_args()
 
     TestsPassed = testAll(Args)
     if not TestsPassed:
         print "ERROR: Tests failed."
         sys.exit(42)