2719 : "Formal parameter with __declspec(align('n')) won't be aligned",

4005 : "Macro redefinition",

4100 : "Unreferenced formal parameter",

4189 : "Local variable is initialized but not referenced",

4245 : "Signed/unsigned mismatch",

4505 : "Unreferenced local function has been removed",

4611 : "interaction between '_setjmp' and C++ object destruction is non-portable",

4703 : "Potentially uninitialized local pointer variable used",

4789 : "Destination of memory copy is too small",

6001 : "Using uninitialized memory",

6029 : "Possible buffer overrun: use of unchecked value",

6053 : "Call to <function> may not zero-terminate string",

6054 : "String may not be zero-terminated",

6057 : "Buffer overrun due to number of characters/number of bytes mismatch",

6059 : "Incorrect length parameter",

6063 : "Missing string argument",

6064 : "Missing integer argument",

6066 : "Non-pointer passed as parameter when pointer is required",

6067 : "Parameter in call must be the address of the string",

6200 : "Index is out of valid index range for non-stack buffer",

6201 : "Out of range index",

6202 : "Buffer overrun for stack allocated variable in call to function",

6203 : "Buffer overrun for non-stack buffer",

6204 : "Possible buffer overrun: use of unchecked parameter",

6209 : "Using sizeof when a character count might be needed. Annotate with OUT_Z_CAP or its relatives",

6216 : "Compiler-inserted cast between semantically different integral types: a Boolean type to HRESULT",

6221 : "Implicit cast between semantically different integer types",

6219 : "Implicit cast between semantically different integer types",

6236 : "(<expression> || <non-zero constant>) is always a non-zero constant",

6244 : "Local declaration shadows declaration of same name in global scope",

6246 : "Local declaration shadows declaration of same name in outer scope",

6248 : "Setting a SECURITY_DESCRIPTOR's DACL to NULL will result in an unprotected object",

6258 : "Using TerminateThread does not allow proper thread clean up",

6262 : "Excessive stack usage in function",

6263 : "Using _alloca in a loop: this can quickly overflow stack",

6269 : "Possible incorrect order of operations: dereference ignored",

6270 : "Missing float argument to varargs function",

6271 : "Extra argument passed: parameter is not used by the format string",

6272 : "Non-float passed as argument <number> when float is required",

6273 : "Non-integer passed as a parameter when integer is required",

6277 : "NULL application name with an unquoted path results in a security vulnerability if the path contains spaces",

6278 : "Buffer is allocated with array new [], but deleted with scalar delete. Destructors will not be called",

6281 : "Incorrect order of operations: relational operators have higher precedence than bitwise operators",

6282 : "Incorrect operator: assignment of constant in Boolean context",

6283 : "Buffer is allocated with array new [], but deleted with scalar delete",

6284 : "Object passed as a parameter when string is required",

6286 : "(<non-zero constant> || <expression>) is always a non-zero constant.",

6287 : "Redundant code: the left and right sub-expressions are identical",

6290 : "Bitwise operation on logical result: ! has higher precedence than &. Use && or (!(x & y)) instead",

6293 : "Ill-defined for-loop: counts down from minimum",

6294 : "Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed",

6295 : "Ill-defined for-loop: Loop executed indefinitely",

6297 : "Arithmetic overflow: 32-bit value is shifted, then cast to 64-bit value",

6298 : "Using a read-only string <pointer> as a writable string argument",

6302 : "Format string mismatch: character string passed as parameter when wide character string is required",

6306 : "Incorrect call to 'fprintf*': consider using 'vfprintf*' which accepts a va_list as an argument",

6313 : "Incorrect operator: zero-valued flag cannot be tested with bitwise-and. Use an equality test to check for zero-valued flags",

6316 : "Incorrect operator: tested expression is constant and non-zero. Use bitwise-and to determine whether bits are set",

6318 : "Ill-defined __try/__except: use of the constant EXCEPTION_CONTINUE_SEARCH ",

6328 : "Wrong parameter type passed",

6330 : "'const char' passed as a parameter when 'unsigned char' is required",

6333 : "Invalid parameter: passing MEM_RELEASE and a non-zero dwSize parameter to 'VirtualFree' is not allowed",

6334 : "Sizeof operator applied to an expression with an operator might yield unexpected results",

6336 : "Arithmetic operator has precedence over question operator, use parentheses to clarify intent",

6385 : "Out of range read",

6386 : "Out of range write",

6522 : "Invalid size specification: expression must be of integral type",

6523 : "Invalid size specification: parameter 'size' not found",

28199 : "Using possibly uninitialized: The variable has had its address taken but no assignment to it has been discovered.",

for sourcePath in remaps.keys():

if textline.startswith(sourcePath):

return textline.replace(sourcePath, remaps[sourcePath])

# Create a dictionary in which to store the results

# The keys for the dictionary are "warning 6328 in c:\buildbot\..."

# This means that the count of keys is not particularly meaningful. The

# length of each data item tells you the total number of raw warnings, but

# some of those are duplicates (from the same file being compiled multiple

# times). The UniqueWarningCount function can be used to find the number of

# unique warnings in each record.

#

# This probably could have been designed better, perhaps by having the key

# include the line number. Probably not worth changing now.

result = {}

lines = open(logName).readlines()

# First look for compiler crashes. Joy.

if analyzeconfig.abortOnCompilerCrash:

compilerCrashes = 0

for line in lines:

# Look for signs that the compiler crashed and if it did then abort.

if line.count("Please choose the Technical Support command on the Visual C++") > 0:

compilerCrashes += 1

# Print a message in the warning format so that we can see how many times the

# compiler crashed on the buildbot waterfall page.

print "cl.exe(1): warning : internal compiler error, the compiler has crashed. Aborting code analysis."

# If the compiler crashes one or more times then give up.

if compilerCrashes > 0:

sys.exit(0)

warningCount = 0

ignoredCount = 0

namePrinted = False

for line in lines:

# Some of the paths in the output lines have slashes instead of backslashes.

line = line.replace("/", "\\")

ignored = False

for path in ignorePaths:

if line.count(path) > 0:

ignored = True

ignoredCount += 1

if ignored:

continue

filename = ""

type = "warning"

# Look for warnings with filename and line number. The groups returned

# are:

# file name

# line number

# warning number

# warning text

# optionally (warningWithLinesRe only) the lines implicated in the warning

warningMatch = warningWithLinesRe.match(line)

if not warningMatch:

warningMatch = warningRe.match(line)

if not warningMatch:

warningMatch = errorRe.match(line)

if warningMatch:

type = "error"

# We want to record how many errors of a particular type occur in a particular source

# file so we create a dictionary with [file name, warning number, isError] as the key.

if warningMatch:

filename = warningMatch.groups()[0]

lineNumber = warningMatch.groups()[1]

warningNumber = warningMatch.groups()[2]

warningText = warningMatch.groups()[3]

key = "%s %s in %s" % (type, warningNumber, filename)

data = "%s(%s): %s C%s%s" % (filename, lineNumber, type, warningNumber, warningText)

warningCount += 1

if key in result:

result[key] += [data]

else:

result[key] = [data]

elif line.find(": warning") >= 0:

pass # Ignore these warnings for now

elif line.find(": error ") >= 0:

if not namePrinted:

namePrinted = True

print " Unhandled errors found in '%s'" % logName

print " %s" % line.strip()

uniqueWarningCount = 0

uniqueInformationalCount = 0

for key in result.keys():

count = UniqueWarningCount(result[key])

match = parseKeyRe.match(key)

warningNumber = match.groups()[1]

if warningNumber in informationalWarnings:

uniqueInformationalCount += count

else:

uniqueWarningCount += count

print "%d lines of output in %s, %d issues found, %d ignored, plus %d informational." % (len(lines), logName, uniqueWarningCount, ignoredCount, uniqueInformationalCount)

print ""

printedAlready = {}

for newEntry in newEntries:

if not newEntry in printedAlready:

printedAlready[newEntry] = True

# When printing out the list of warnings that have been fixed

# replace ": warning" with a string that will not be

# recognized by the buildbot parser as a warning so that the

# break e-mails will only include new warnings.

# Yes, this is a hack. In the future a custom parser/filter

# for the e-mails would be better.

if sanitize:

newEntry = newEntry.replace(": warning", ": wrning")

newEntry = newEntry.replace(": error", ": eror")

# Warnings may be encountered multiple times (header files included

# from many places, or source files compiled multiple times) and these

# are all added to the warning record. However, for determining

# unique warnings we want to filter out these duplicates.

alreadySeen = {}

count = 0

for warning in warningRecord:

if not warning in alreadySeen:

alreadySeen[warning] = True

count += 1

newWarningsFound = False

warningsFixed = False

fatalWarningsFound = False

warningCounts = {}

oldWarningCounts = {}

sampleWarnings = {}

for key in new.keys():

match = parseKeyRe.match(key)

warningNumber = int(match.groups()[1])

if warningNumber in alwaysFatalWarnings:

fatalWarningsFound = True

if warningNumber in warningCounts:

warningCounts[warningNumber] += UniqueWarningCount(new[key])

else:

warningCounts[warningNumber] = UniqueWarningCount(new[key])

sampleWarnings[warningNumber] = new[key][0]

if not key in old:

newWarningsFound = True

if warningNumber in fatalWhenNewWarnings:

fatalWarningsFound = True

for key in old.keys():

match = parseKeyRe.match(key)

warningNumber = int(match.groups()[1])

if warningNumber in oldWarningCounts:

oldWarningCounts[warningNumber] += UniqueWarningCount(old[key])

else:

oldWarningCounts[warningNumber] = UniqueWarningCount(old[key])

if not warningNumber in sampleWarnings:

sampleWarnings[warningNumber] = old[key][0]

if not key in new:

warningsFixed = True

if fatalWarningsFound:

errorCode = 10

elif newWarningsFound:

errorCode = 10

else:

errorCode = 0

# Make three passes through the warnings so that we group fatal, fatal-when-new, and

# new warnings together, with the fatal warnings first.

# The colons at the beginning of blank lines are so that buildbot's BuildAnalyze.createSummary

# will retain those lines.

for type in ["Fatal", "Fatal-when-new", "New"]:

fixing = "required"

if type == "New":

fixing = "optional"

message = "%s warning or warnings found. Fixing these is %s:\n:" % (type, fixing)

for key in new.keys():

newEntries = new[key]

match = parseKeyRe.match(key)

warningNumber = int(match.groups()[1])

if warningNumber in alwaysFatalWarnings:

if type == "Fatal":

print message

message = ":"

PrintEntries(newEntries, " ", False)

elif not key in old:

if warningNumber in fatalWhenNewWarnings:

if type == "Fatal-when-new":

print message

message = ":"

PrintEntries(newEntries, " ", False)

else:

if type == "New":

print message

message = ":"

PrintEntries(newEntries, " ", False)

# If message is short then that means it was printed and then assigned to a short

# string, which means some warnings of this type were printed, which means we should

# print a separator.

if len(message) < 2:

print ":\n:\n:\n:\n:"

if warningsFixed:

print "\n\n\n\n\nOld issues that have been fixed:"

for key in old.keys():

oldEntries = old[key]

if not key in new:

print "Warning fixed in %s:" % newname

print "%d times:" % len(oldEntries)

PrintEntries(oldEntries, " ", True)

print ""

else:

newEntries = new[key]

# Disable printing decreased warning counts -- too much noise.

if False and len(newEntries) < len(oldEntries):

print "Decreased wrning count:"

print " Old (%s):" % oldname

print " %d times:" % len(oldEntries)

PrintEntries(oldEntries, " ", True)

print " New (%s):" % newname

print " %d times:" % len(newEntries)

PrintEntries(newEntries, " ", True)

print ""

print "\n\n\n"

warningStats = []

for warningNumber in warningCounts.keys():

warningCount = warningCounts[warningNumber]

if warningNumber in oldWarningCounts:

warningDiff = warningCount - oldWarningCounts[warningNumber]

else:

warningDiff = warningCount

warningStats.append((warningCount, warningNumber, warningDiff))

for warningNumber in oldWarningCounts.keys():

if not warningNumber in warningCounts:

warningStats.append((0, warningNumber, -oldWarningCounts[warningNumber]))

warningStats.sort()

warningStats.reverse()

for warningStat in warningStats:

warningNumber = warningStat[1]

description = ""

if warningNumber in warningsToText:

description = ", %s" % warningsToText[warningNumber]

else:

# Replace warning/error with wrning/eror so that these warning summaries don't trigger the

# warning detection logic.

description = ", example: %s" % sampleWarnings[warningNumber].replace("warning", "wrning").replace("error", "eror")

print "%3d occurrences of C%d, changed %d%s" % (warningStat[0], warningStat[1], warningStat[2], description)

# Print a summary of all stack related warnings in the new data, regardless of whether they were in the old.

bigStackCulprits = {}

allocaCulprits = {}

# c:\src\simplify.cpp(1840): warning C6262: : Function uses '28708' bytes of stack: exceeds /analyze:stacksize'16384'. Consider moving some data to heap

stackUsedRe = re.compile("(.*): warning C6262: Function uses '(\d*)' .*")

print "\n\n\n"

print "Stack related summary:"

print "C6263: Using _alloca in a loop: this can quickly overflow stack"

bigStackCulprits = []

for key in new.keys():

# warning C6262: Function uses '400352' bytes of stack

# warning C6263: Using _alloca in a loop

stackMatch = parseKeyRe.match(key)

if stackMatch:

warningNumber = stackMatch.groups()[1]

if warningNumber == "6262":

#print "Found warning %s in %s" % (warningNumber, stackMatch.groups()[2])

entries = new[key]

printed = {}

for entry in entries:

if not entry in printed:

match = stackUsedRe.match(entry)

if match:

location = match.groups()[0]

stackBytes = int(match.groups()[1])

printed[entry] = True

bigStackCulprits.append((stackBytes, location))

elif warningNumber == "6263":

#print "Found warning %s in %s" % (warningNumber, stackMatch.groups()[2])

entries = new[key]

printed = {}

for entry in entries:

if not entry in printed:

print Cleanup(entry[:entry.find(": ")])

printed[entry] = True

print "\n\n"

print "C6262: Functions that use many bytes of stack"

bigStackCulprits.sort()

bigStackCulprits.reverse()

print "filename(linenumber): bytes"

# Print a sorted summary of functions using excessive stack. It would be tidier

# to print the size first (better alignment) but then the output can't be used

# in the Visual Studio output window to jump to the code in question.

# Get the lengths of all of the file names

lengths = []

for val in bigStackCulprits:

lengths.append(len(Cleanup(val[1])))

lengths.sort()

if len(lengths) > 0:

# Set the length at the 9xth percentile so that most of the sizes

# are lined up.

formatLength = lengths[int(len(lengths)*.97)]

formatString = "%%-%ds: %%7d" % formatLength

for val in bigStackCulprits:

print formatString % (Cleanup(val[1]), val[0])

# Print a list of all of the outstanding warnings

print "\n\n\n"

print "Outstanding warnings are:"

DumpWarnings(new, True)

filePrinted = {}

# If we just scan the dictionary then warnings will be grouped

# by warning-number-in-file, but different warning numbers from the

# same file will be scattered, and different files from the same

# directory will also be scattered.

# We really want warnings sorted by path name. To do that we scan

# through the dictionary and add all of the entries to a dictionary

# whose primary key is filename (path). Then we sort those keys.

warningsByFile = {}

for key in new.keys():

match = parseKeyRe.match(key)

type, warningNumber, filename = match.groups()

if filename in warningsByFile:

warningsByFile[filename].append(key)

else:

warningsByFile[filename] = [key]

filenames = warningsByFile.keys()

filenames.sort();

for filename in filenames:

for key in warningsByFile[filename]:

match = parseKeyRe.match(key)

warningNumber = match.groups()[1]

if ignoreInformational and warningNumber in informationalWarnings:

pass

else:

newEntries = new[key]

print "%d times:" % len(newEntries)

PrintEntries(newEntries, " ", True)

print ""

if ignoreInformational:

# Print the 6244 and 6246 warnings together in a group. We print

# them here so that they are sorted by file name.

print "\n\n\nVariable shadowing warnings"

for filename in filenames:

for key in warningsByFile[filename]:

match = parseKeyRe.match(key)

warningNumber = match.groups()[1]

if warningNumber == "6244" or warningNumber == "6246":

newEntries = new[key]

PrintEntries(newEntries, " ", True)

# Special indicator for last-known-good. This means that the script

# should look for analysislkg.txt and extract a file name from it.

# Temporarily have "2" be equivalent to "lkg" to allow for a transition

# to the lkg model.

if arg == "lkg" or arg == "2":

try:

lines = open(lkgFilename).readlines()

if len(lines) > 0:

result = lines[0].strip()

print "LKG analysis results are in '%s'" % result

return result

else:

print "No data found in %s" % lkgFilename

except IOError:

print "Failed to open %s" % lkgFilename

arg = 2

try:

x = int(arg)

except:

return arg

if x <= 0:

print "Numerical arguments must be from 1 to numlogs (%s)" % arg

sys.exit(10)

basedir = r"."

dirEntries = os.listdir(basedir)

logRe = re.compile(r"analyze(.*)_cl_(\d+).txt");

logs = []

for entry in dirEntries:

if logRe.match(entry):

logs.append(entry)

# This will throw an exception if there aren't enough log files

# available.

newname = os.path.join(basedir, logs[-x])