Merge pull request #518 from ThePortlandGroup/nv_stage

Pull 2018-06-29T11-41 Recent NVIDIA Changes

Author: sscalpone

test/tools/check_compilation.py

@@ -0,0 +1,218 @@
+#
+# Copyright (c) 2016-2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Helper for checking the output of deja-gnu style tests.
+
+This script prints all non-error lines to allow external tools to find other
+problems. It then tries to match up lines with dg-type errors with the errors
+in the ouput file & prints any non-matching errors.
+
+Script allows to match F90 (emited by flang) and PGF90 (emited by pgfortran)
+error prefixes. This functionality can be modified to disable checking error
+prefixes in the future.
+"""
+
+import re
+import argparse
+from collections import namedtuple
+from os.path import basename
+
+# Regex notes:
+#     \S matches any non-whitespace character
+#     \d matches [0-9]
+#     \w matches [A-Za-z_0-9]
+#     .  matches any character except (possibly) line terminators
+#     $  matches end-of-input
+#     Parentheses define a capturing group
+#     (?P<foo> ... ) defines a capturing group accessed with m.group("foo")
+
+# an error listed in the source file:
+dgError = re.compile(r"""
+	^(?P<stmt>.*?)\s*!\s*{\s*   # fortran statement before error marker
+	(?P<dg>dg-)?                # dg- prefix means text need not match
+	(?P<sev>(error|warning))\s* # severify
+	\"(?P<prefix>(?:PG)?F\d\d)  # error prefix
+	-[WSF]-\d+-                 # PGI severity and error number
+	(?P<text>.*)\"              # text of message
+	\s*(?P<lineno>\d*)          # optional line number of message
+	\s*}\s*$
+	""", re.VERBOSE)
+
+# an error output from the fortran compiler:
+pgfError = re.compile(r"""
+	(?P<prefix>(?:PG)?F\d\d)-            # error prefix
+	(?P<sev>[WSF])-\d+-(?P<text>.+?)\s*  # text & sev of error
+	\((?P<file>\S+)                      # file name
+	(:\s*(?P<lineno>\d+))?\)$            # optional line number
+	""", re.VERBOSE)
+
+# Compiler crash
+terminatedError = re.compile(r"TERMINATED by signal")
+
+ErrorInfo = namedtuple("ErrorInfo", "file lineno sev prefix text")
+
+def main():
+	args = processArgs()
+	terminated, logErrors = getLogErrors(args.log)
+	sourceErrors = getSourceErrors(getFileSet(args.source, logErrors))
+	if args.dump:
+		dumpErrorSet(logErrors, title="Log Errors:")
+		dumpErrorSet(sourceErrors, title="Source Errors:")
+	checkErrorsMatch(terminated, logErrors, sourceErrors, basename(args.compiler))
+
+def processArgs():
+	""" Process command line arguments """
+
+	parser = argparse.ArgumentParser()
+	parser.add_argument("source", help="source file")
+	parser.add_argument("log", help="log file")
+	parser.add_argument("compiler", nargs='?', help="Name of the compiler executable or path to it", default="pgf90")
+	parser.add_argument("--dump", help="dump the error lists", action="store_true")
+	return parser.parse_args()
+
+def getLogErrors(log):
+	"""
+	Extract erros from the log file
+
+	:param log: log file path
+	"""
+
+	terminated = False
+	errorList = []
+	with open(log, "r") as handle:
+		for line in handle:
+			m = pgfError.match(line)
+			if m:
+				text = m.group("text")
+				prefix = m.group("prefix")
+				sev = "warning" if m.group("sev") == "W" else "error"
+				file = m.group("file")
+				lineno = m.group("lineno") if m.group("lineno") else ""
+				errorList.append(ErrorInfo(file, lineno, sev, prefix, text))
+			elif terminatedError.search(line):
+				terminated = True
+			else:
+				print line,
+	return terminated, errorList
+
+def getFileSet(source, logErrors):
+	"""
+	Get set of files to extract errors, containing original source file and
+	any files mentioned in the errors
+
+	:param source: source file that was compiled
+	:parma logErrors: list of error tuples from the log
+	"""
+
+	fileSet = set([source])
+	for e in logErrors:
+		fileSet.add(e.file)
+	return fileSet
+
+def getSourceErrors(fileSet):
+	"""
+	Collect error messages from source files
+
+	:param fileSet: list of file names to process
+	"""
+	errorList = []
+	saveList = []  # errors saved up for next line that isn't just dg-error
+	for f in fileSet:
+		with open(f, "r") as handle:
+			lineno = 0
+			for line in handle:
+				lineno += 1
+				m = dgError.search(line)
+				if m:
+					dg = m.group("dg")  # dg-error vs. error
+					stmt = m.group("stmt")  # fortran stmt before dg-error
+					text = m.group("text") if not dg else ""
+					prefix = m.group("prefix") if not dg else ""
+					sev = m.group("sev")
+					l = m.group("lineno")  # lineno specific in dg-error
+					if l != "":
+						errorList.append(ErrorInfo(f, l, sev, prefix, text))
+					elif stmt != "" or dg:
+						errorList.append(ErrorInfo(f, str(lineno), sev, prefix, text))
+					else:
+						saveList.append(ErrorInfo(f, "", sev, prefix, text))
+				if len(saveList) > 0 and (not m or m.group("stmt")):
+					# this was not a full-line dg-error, so saveList goes with this line
+					for e in saveList:
+						errorList.append(ErrorInfo(e.file, str(lineno), e.sev, e.prefix, e.text))
+					saveList = []
+	return errorList + saveList
+
+def checkErrorsMatch(terminated, logErrors, sourceErrors, compiler):
+	"""
+	Report error mismatches
+
+	:param terminated: log indicates that compiler was terminated
+	:param logErrors: error tuples from the compilation log
+	:param sourceErrors: error tuples from the source file(s)
+	:param compiler: compiler executable name
+	"""
+
+	fail = None
+	for e in logErrors:
+		if not removeMatch(e, sourceErrors, (compiler == "flang")):
+			fail = True
+			print "Unexpected:", e.sev, e.file, e.lineno, e.text
+	for e in sourceErrors:
+		fail = True
+		print "Missed:", e.sev, e.file, e.lineno, e.text
+	if fail or terminated:
+		print "FAIL"
+	else:
+		print "PASS"
+
+def removeMatch(e, errors, matchF90):
+	"""
+	If e matches one of errors, remove it and return True
+
+	:param matchF90: match F90 prefix in error to PGF90 in entry in e
+	"""
+	for e2 in errors:
+		if e.file != e2.file: continue
+		if e.lineno != e2.lineno: continue
+		if e.sev != e2.sev: continue
+		if e2.text != "" and e.text != e2.text: continue
+		if e2.prefix != "":
+			if (not matchF90) and e.prefix != e2.prefix: continue
+			if matchF90 and (e.prefix != "F90" or e2.prefix != "PGF90"): continue
+		errors.remove(e2)
+		return True
+	return False
+
+def dumpErrorSet(errors, title):
+	"""
+	Dump collected errors 
+
+	:param erros: error list
+	:param title: optional title
+	"""
+	if title:
+		print title
+	if len(errors) == 0:
+		print "    (none)"
+	else:
+		for e in errors:
+			print "   ", e.sev, e.file, e.lineno, e.prefix if e.prefix != None else "", e.text if e.text != None else ""
+
+
+if __name__=="__main__":
+   main()

tools/flang1/flang1exe/semant3.c

@@ -531,7 +531,7 @@ semant3(int rednum, SST *top)
           strcmp(SYMNAME(FVALG(sptr)), SYMNAME(gbl.currsub)) == 0 &&
           strcmp(SYMNAME(sptr), SYMNAME(gbl.currsub)) == 0 &&
           strcmp(SYMNAME(sptr), SYMNAME(FVALG(gbl.currsub))) == 0) {
-        /* FS#20696: replace with correct LHS symbol */
+        /* replace with correct LHS symbol */
         sptr = gbl.currsub;
         if (SST_IDG(RHS(2)) == S_LVALUE || SST_IDG(RHS(2)) == S_EXPR) {
           SST_LSYMP(RHS(2), sptr);