diff --git a/.flake8 b/.flake8 index 39188cae5c115..549c9aa559695 100644 --- a/.flake8 +++ b/.flake8 @@ -6,11 +6,12 @@ filename = ./benchmark/scripts/Benchmark_Driver, ./benchmark/scripts/Benchmark_DTrace.in, ./benchmark/scripts/Benchmark_GuardMalloc.in, + ./benchmark/scripts/Benchmark_QuickCheck.in, ./benchmark/scripts/Benchmark_RuntimeLeaksRunner.in, + ./benchmark/scripts/run_smoke_bench, ./docs/scripts/ns-html2rst, - ./test/Driver/Inputs/fake-toolchain/clang++, ./test/Driver/Inputs/fake-toolchain/ld, ./utils/80+-check, @@ -30,7 +31,6 @@ filename = ./utils/recursive-lipo, ./utils/round-trip-syntax-test, ./utils/rth, - ./utils/run-remote, ./utils/run-test, ./utils/scale-test, ./utils/submit-benchmark-results, diff --git a/CMakeLists.txt b/CMakeLists.txt index 852ef3cf48a48..ed6f6c17987a4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -32,6 +32,11 @@ endif() ENABLE_LANGUAGE(C) +# Use C++14. +set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to conform to") +set(CMAKE_CXX_STANDARD_REQUIRED YES) +set(CMAKE_CXX_EXTENSIONS NO) + # First include general CMake utilities. include(SwiftUtils) include(CheckSymbolExists) diff --git a/benchmark/scripts/Benchmark_DTrace.in b/benchmark/scripts/Benchmark_DTrace.in index 273c538cd650f..300291813b96d 100644 --- a/benchmark/scripts/Benchmark_DTrace.in +++ b/benchmark/scripts/Benchmark_DTrace.in @@ -19,20 +19,17 @@ import sys DRIVER_LIBRARY_PATH = "@PATH_TO_DRIVER_LIBRARY@" sys.path.append(DRIVER_LIBRARY_PATH) -DTRACE_PATH = os.path.join(DRIVER_LIBRARY_PATH, 'swift_stats.d') +DTRACE_PATH = os.path.join(DRIVER_LIBRARY_PATH, "swift_stats.d") import perf_test_driver # noqa (E402 module level import not at top of file) # Regexes for the XFAIL_LIST. Matches against '([Onone|O|Osize],TestName)' -XFAIL_LIST = [ -] +XFAIL_LIST = [] class DTraceResult(perf_test_driver.Result): - def __init__(self, name, status, output, csv_output): - perf_test_driver.Result.__init__( - self, name, status, output, XFAIL_LIST) + perf_test_driver.Result.__init__(self, name, status, output, XFAIL_LIST) self.csv_output = csv_output def is_failure(self): @@ -40,40 +37,38 @@ class DTraceResult(perf_test_driver.Result): @classmethod def data_headers(cls): - return [ - 'Name', 'Result', 'Total RR Opts', 'Total RR Opts/Iter'] + return ["Name", "Result", "Total RR Opts", "Total RR Opts/Iter"] @classmethod def data_format(cls, max_test_len): non_name_headers = DTraceResult.data_headers()[1:] - fmt = ('{:<%d}' % (max_test_len + 5)) + \ - ''.join(['{:<%d}' % (len(h) + 2) for h in non_name_headers]) + fmt = ("{:<%d}" % (max_test_len + 5)) + "".join( + ["{:<%d}" % (len(h) + 2) for h in non_name_headers] + ) return fmt @classmethod def print_data_header(cls, max_test_len, csv_output): headers = cls.data_headers() if csv_output: - print(','.join(headers)) + print(",".join(headers)) return print(cls.data_format(max_test_len).format(*headers)) def print_data(self, max_test_len): result = [self.get_name(), self.get_result()] + map(str, self.output) if self.csv_output: - print(','.join(result)) + print(",".join(result)) return print(DTraceResult.data_format(max_test_len).format(*result)) class DTraceBenchmarkDriver(perf_test_driver.BenchmarkDriver): - def __init__(self, binary, xfail_list, csv_output): perf_test_driver.BenchmarkDriver.__init__( - self, binary, xfail_list, - enable_parallel=True, - opt_levels=['O']) + self, binary, xfail_list, enable_parallel=True, opt_levels=["O"] + ) self.csv_output = csv_output def print_data_header(self, max_test_len): @@ -83,23 +78,37 @@ class DTraceBenchmarkDriver(perf_test_driver.BenchmarkDriver): return {} def process_input(self, data): - test_name = '({}_{})'.format(data['opt'], data['test_name']) + test_name = "({}_{})".format(data["opt"], data["test_name"]) print("Running {}...".format(test_name)) sys.stdout.flush() def get_results_with_iters(iters): e = os.environ - e['SWIFT_DETERMINISTIC_HASHING'] = '1' - p = subprocess.Popen([ - 'sudo', 'dtrace', '-s', DTRACE_PATH, - '-c', '%s %s %s %s' % (data['path'], data['test_name'], - '--num-iters=%d' % iters, - '--num-samples=2') - ], stdout=subprocess.PIPE, stderr=open('/dev/null', 'w'), env=e) + e["SWIFT_DETERMINISTIC_HASHING"] = "1" + p = subprocess.Popen( + [ + "sudo", + "dtrace", + "-s", + DTRACE_PATH, + "-c", + "%s %s %s %s" + % ( + data["path"], + data["test_name"], + "--num-iters=%d" % iters, + "--num-samples=2", + ), + ], + stdout=subprocess.PIPE, + stderr=open("/dev/null", "w"), + env=e, + ) results = [x for x in p.communicate()[0].split("\n") if len(x) > 0] return [ - x.split(',')[1] for x in - results[results.index('DTRACE RESULTS') + 1:]] + x.split(",")[1] for x in results[results.index("DTRACE RESULTS") + 1 :] + ] + iter_2_results = get_results_with_iters(2) iter_3_results = get_results_with_iters(3) iter_5_results = get_results_with_iters(5) @@ -136,16 +145,18 @@ SWIFT_BIN_DIR = os.path.dirname(os.path.abspath(__file__)) def parse_args(): parser = argparse.ArgumentParser() parser.add_argument( - '-filter', + "-filter", type=str, default=None, - help='Filter out any test that does not match the given regex') + help="Filter out any test that does not match the given regex", + ) parser.add_argument( - '--emit-csv', + "--emit-csv", default=False, - action='store_true', + action="store_true", help="Emit csv output", - dest='csv_output') + dest="csv_output", + ) return parser.parse_args() diff --git a/benchmark/scripts/Benchmark_Driver b/benchmark/scripts/Benchmark_Driver index 31808852bcf22..1e84738562bfe 100755 --- a/benchmark/scripts/Benchmark_Driver +++ b/benchmark/scripts/Benchmark_Driver @@ -61,23 +61,22 @@ class BenchmarkDriver(object): self.results = {} # Set a constant hash seed. Some tests are currently sensitive to # fluctuations in the number of hash collisions. - os.environ['SWIFT_DETERMINISTIC_HASHING'] = '1' + os.environ["SWIFT_DETERMINISTIC_HASHING"] = "1" def _invoke(self, cmd): - return self._subprocess.check_output( - cmd, stderr=self._subprocess.STDOUT) + return self._subprocess.check_output(cmd, stderr=self._subprocess.STDOUT) @property def test_harness(self): """Full path to test harness binary.""" - suffix = (self.args.optimization if hasattr(self.args, 'optimization') - else 'O') + suffix = self.args.optimization if hasattr(self.args, "optimization") else "O" return os.path.join(self.args.tests, "Benchmark_" + suffix) def _git(self, cmd): """Execute the Git command in the `swift-repo`.""" return self._invoke( - ('git -C {0} '.format(self.args.swift_repo) + cmd).split()).strip() + ("git -C {0} ".format(self.args.swift_repo) + cmd).split() + ).strip() @property def log_file(self): @@ -89,27 +88,28 @@ class BenchmarkDriver(object): return None log_dir = self.args.output_dir harness_name = os.path.basename(self.test_harness) - suffix = '-' + time.strftime('%Y%m%d%H%M%S', time.localtime()) + suffix = "-" + time.strftime("%Y%m%d%H%M%S", time.localtime()) if self.args.swift_repo: log_dir = os.path.join( - log_dir, self._git('rev-parse --abbrev-ref HEAD')) # branch - suffix += '-' + self._git('rev-parse --short HEAD') # revision - return os.path.join(log_dir, harness_name + suffix + '.log') + log_dir, self._git("rev-parse --abbrev-ref HEAD") + ) # branch + suffix += "-" + self._git("rev-parse --short HEAD") # revision + return os.path.join(log_dir, harness_name + suffix + ".log") @property def _cmd_list_benchmarks(self): # Use tab delimiter for easier parsing to override the default comma. # (The third 'column' is always comma-separated list of tags in square # brackets -- currently unused here.) - return [self.test_harness, '--list', '--delim=\t'] + ( - ['--skip-tags='] if (self.args.benchmarks or - self.args.filters) else []) + return [self.test_harness, "--list", "--delim=\t"] + ( + ["--skip-tags="] if (self.args.benchmarks or self.args.filters) else [] + ) def _get_tests(self): """Return a list of performance tests to run.""" number_name_pairs = [ - line.split('\t')[:2] for line in - self._invoke(self._cmd_list_benchmarks).split('\n')[1:-1] + line.split("\t")[:2] + for line in self._invoke(self._cmd_list_benchmarks).split("\n")[1:-1] ] # unzip list of pairs into 2 lists test_numbers, self.all_tests = map(list, zip(*number_name_pairs)) @@ -122,55 +122,79 @@ class BenchmarkDriver(object): def _tests_matching_patterns(self): regexes = [re.compile(pattern) for pattern in self.args.filters] - return sorted(list(set([name for pattern in regexes - for name in self.all_tests - if pattern.match(name)]))) + return sorted( + list( + set( + [ + name + for pattern in regexes + for name in self.all_tests + if pattern.match(name) + ] + ) + ) + ) def _tests_by_name_or_number(self, test_numbers): benchmarks = set(self.args.benchmarks) number_to_name = dict(zip(test_numbers, self.all_tests)) - tests_by_number = [number_to_name[i] - for i in benchmarks.intersection(set(test_numbers))] - return sorted(list(benchmarks - .intersection(set(self.all_tests)) - .union(tests_by_number))) - - def run(self, test=None, num_samples=None, num_iters=None, - sample_time=None, verbose=None, measure_memory=False, - quantile=None): + tests_by_number = [ + number_to_name[i] for i in benchmarks.intersection(set(test_numbers)) + ] + return sorted( + list(benchmarks.intersection(set(self.all_tests)).union(tests_by_number)) + ) + + def run( + self, + test=None, + num_samples=None, + num_iters=None, + sample_time=None, + verbose=None, + measure_memory=False, + quantile=None, + ): """Execute benchmark and gather results.""" num_samples = num_samples or 0 num_iters = num_iters or 0 # automatically determine N to run for 1s sample_time = sample_time or 0 # default is 1s cmd = self._cmd_run( - test, num_samples, num_iters, sample_time, - verbose, measure_memory, quantile) + test, num_samples, num_iters, sample_time, verbose, measure_memory, quantile + ) output = self._invoke(cmd) results = self.parser.results_from_string(output) return results.items()[0][1] if test else results - def _cmd_run(self, test, num_samples, num_iters, sample_time, - verbose, measure_memory, quantile): + def _cmd_run( + self, + test, + num_samples, + num_iters, + sample_time, + verbose, + measure_memory, + quantile, + ): cmd = [self.test_harness] if test: cmd.append(test) else: - cmd.extend([self.test_number.get(name, name) - for name in self.tests]) + cmd.extend([self.test_number.get(name, name) for name in self.tests]) if num_samples > 0: - cmd.append('--num-samples={0}'.format(num_samples)) + cmd.append("--num-samples={0}".format(num_samples)) if num_iters > 0: - cmd.append('--num-iters={0}'.format(num_iters)) + cmd.append("--num-iters={0}".format(num_iters)) if sample_time > 0: - cmd.append('--sample-time={0}'.format(sample_time)) + cmd.append("--sample-time={0}".format(sample_time)) if verbose: - cmd.append('--verbose') + cmd.append("--verbose") if measure_memory: - cmd.append('--memory') + cmd.append("--memory") if quantile: - cmd.append('--quantile={0}'.format(quantile)) - cmd.append('--delta') + cmd.append("--quantile={0}".format(quantile)) + cmd.append("--delta") return cmd def run_independent_samples(self, test): @@ -178,14 +202,18 @@ class BenchmarkDriver(object): Returns the aggregated result of independent benchmark invocations. """ + def merge_results(a, b): a.merge(b) return a - return reduce(merge_results, - [self.run(test, measure_memory=True, - num_iters=1, quantile=20) - for _ in range(self.args.independent_samples)]) + return reduce( + merge_results, + [ + self.run(test, measure_memory=True, num_iters=1, quantile=20) + for _ in range(self.args.independent_samples) + ], + ) def log_results(self, output, log_file=None): """Log output to `log_file`. @@ -196,11 +224,11 @@ class BenchmarkDriver(object): dir = os.path.dirname(log_file) if not os.path.exists(dir): os.makedirs(dir) - print('Logging results to: %s' % log_file) - with open(log_file, 'w') as f: + print("Logging results to: %s" % log_file) + with open(log_file, "w") as f: f.write(output) - RESULT = '{:>3} {:<40} {:>7} {:>7} {:>6} {:>10} {:>6} {:>7} {:>10}' + RESULT = "{:>3} {:<40} {:>7} {:>7} {:>6} {:>10} {:>6} {:>7} {:>10}" def run_and_log(self, csv_console=True): """Run benchmarks and continuously log results to the console. @@ -212,19 +240,41 @@ class BenchmarkDriver(object): format is justified columns. """ format = ( - (lambda values: ','.join(values)) if csv_console else - (lambda values: self.RESULT.format(*values))) # justified columns + (lambda values: ",".join(values)) + if csv_console + else (lambda values: self.RESULT.format(*values)) + ) # justified columns def console_log(values): print(format(values)) def result_values(r): - return map(str, [r.test_num, r.name, r.num_samples, r.min, - r.samples.q1, r.median, r.samples.q3, r.max, - r.max_rss]) - - header = ['#', 'TEST', 'SAMPLES', 'MIN(μs)', 'Q1(μs)', 'MEDIAN(μs)', - 'Q3(μs)', 'MAX(μs)', 'MAX_RSS(B)'] + return map( + str, + [ + r.test_num, + r.name, + r.num_samples, + r.min, + r.samples.q1, + r.median, + r.samples.q3, + r.max, + r.max_rss, + ], + ) + + header = [ + "#", + "TEST", + "SAMPLES", + "MIN(μs)", + "Q1(μs)", + "MEDIAN(μs)", + "Q3(μs)", + "MAX(μs)", + "MAX_RSS(B)", + ] console_log(header) results = [header] for test in self.tests: @@ -232,10 +282,10 @@ class BenchmarkDriver(object): console_log(result) results.append(result) - print( - '\nTotal performance tests executed: {0}'.format(len(self.tests))) - return (None if csv_console else - ('\n'.join([','.join(r) for r in results]) + '\n')) # csv_log + print("\nTotal performance tests executed: {0}".format(len(self.tests))) + return ( + None if csv_console else ("\n".join([",".join(r) for r in results]) + "\n") + ) # csv_log @staticmethod def run_benchmarks(args): @@ -255,22 +305,31 @@ class LoggingReportFormatter(logging.Formatter): """ import logging as log - colors = {log.DEBUG: '9', log.INFO: '2', log.WARNING: '3', log.ERROR: '1', - log.CRITICAL: '5'} + + colors = { + log.DEBUG: "9", + log.INFO: "2", + log.WARNING: "3", + log.ERROR: "1", + log.CRITICAL: "5", + } def __init__(self, use_color=False): """Specify if report should use colors; defaults to False.""" - super(LoggingReportFormatter, self).__init__('%(message)s') + super(LoggingReportFormatter, self).__init__("%(message)s") self.use_color = use_color def format(self, record): """Format the log record with level and category.""" msg = super(LoggingReportFormatter, self).format(record) - category = ((record.name.split('.')[-1] + ': ') if '.' in record.name - else '') - return ('\033[1;3{0}m{1}{2}\033[1;0m'.format( - self.colors[record.levelno], category, msg) if self.use_color else - '{0} {1}{2}'.format(record.levelname, category, msg)) + category = (record.name.split(".")[-1] + ": ") if "." in record.name else "" + return ( + "\033[1;3{0}m{1}{2}\033[1;0m".format( + self.colors[record.levelno], category, msg + ) + if self.use_color + else "{0} {1}{2}".format(record.levelname, category, msg) + ) class MarkdownReportHandler(logging.StreamHandler): @@ -284,27 +343,34 @@ class MarkdownReportHandler(logging.StreamHandler): """Initialize the handler and write a Markdown table header.""" super(MarkdownReportHandler, self).__init__(stream) self.setLevel(logging.INFO) - self.stream.write('\n✅ | Benchmark Check Report\n---|---') + self.stream.write("\n✅ | Benchmark Check Report\n---|---") self.stream.flush() - levels = {logging.WARNING: '\n⚠️', logging.ERROR: '\n⛔️', - logging.INFO: '
'} - categories = {'naming': '🔤', 'runtime': '⏱', 'memory': 'Ⓜ️'} + levels = { + logging.WARNING: "\n⚠️", + logging.ERROR: "\n⛔️", + logging.INFO: "
", + } + categories = {"naming": "🔤", "runtime": "⏱", "memory": "Ⓜ️"} quotes_re = re.compile("'") def format(self, record): msg = super(MarkdownReportHandler, self).format(record) - return (self.levels.get(record.levelno, '') + - ('' if record.levelno == logging.INFO else - self.categories.get(record.name.split('.')[-1], '') + ' | ') + - self.quotes_re.sub('`', msg)) + return ( + self.levels.get(record.levelno, "") + + ( + "" + if record.levelno == logging.INFO + else self.categories.get(record.name.split(".")[-1], "") + " | " + ) + + self.quotes_re.sub("`", msg) + ) def emit(self, record): msg = self.format(record) stream = self.stream try: - if (isinstance(msg, unicode) and - getattr(stream, 'encoding', None)): + if isinstance(msg, unicode) and getattr(stream, "encoding", None): stream.write(msg.encode(stream.encoding)) else: stream.write(msg) @@ -313,7 +379,7 @@ class MarkdownReportHandler(logging.StreamHandler): self.flush() def close(self): - self.stream.write('\n\n') + self.stream.write("\n\n") self.stream.flush() super(MarkdownReportHandler, self).close() @@ -328,10 +394,10 @@ class BenchmarkDoctor(object): consumption). """ - log = logging.getLogger('BenchmarkDoctor') - log_naming = log.getChild('naming') - log_runtime = log.getChild('runtime') - log_memory = log.getChild('memory') + log = logging.getLogger("BenchmarkDoctor") + log_naming = log.getChild("naming") + log_runtime = log.getChild("runtime") + log_memory = log.getChild("memory") log.setLevel(logging.DEBUG) def __init__(self, args, driver=None): @@ -343,23 +409,25 @@ class BenchmarkDoctor(object): self.driver = driver or BenchmarkDriver(args) self.results = {} - if hasattr(args, 'markdown') and args.markdown: + if hasattr(args, "markdown") and args.markdown: self.console_handler = MarkdownReportHandler(sys.stdout) else: self.console_handler = logging.StreamHandler(sys.stdout) self.console_handler.setFormatter( - LoggingReportFormatter(use_color=sys.stdout.isatty())) - self.console_handler.setLevel(logging.DEBUG if args.verbose else - logging.INFO) + LoggingReportFormatter(use_color=sys.stdout.isatty()) + ) + self.console_handler.setLevel( + logging.DEBUG if args.verbose else logging.INFO + ) self.log.addHandler(self.console_handler) - self.log.debug('Checking tests: %s', ', '.join(self.driver.tests)) + self.log.debug("Checking tests: %s", ", ".join(self.driver.tests)) self.requirements = [ self._name_matches_benchmark_naming_convention, self._name_is_at_most_40_chars_long, self._no_setup_overhead, self._reasonable_setup_time, self._optimized_runtime_in_range, - self._constant_memory_use + self._constant_memory_use, ] def __del__(self): @@ -368,95 +436,122 @@ class BenchmarkDoctor(object): handler.close() self.log.removeHandler(self.console_handler) - benchmark_naming_convention_re = re.compile(r'[A-Z][a-zA-Z0-9\-.!?]+') - camel_humps_re = re.compile(r'[a-z][A-Z]') + benchmark_naming_convention_re = re.compile(r"[A-Z][a-zA-Z0-9\-.!?]+") + camel_humps_re = re.compile(r"[a-z][A-Z]") @staticmethod def _name_matches_benchmark_naming_convention(measurements): - name = measurements['name'] + name = measurements["name"] match = BenchmarkDoctor.benchmark_naming_convention_re.match(name) - matched = match.group(0) if match else '' + matched = match.group(0) if match else "" composite_words = len(BenchmarkDoctor.camel_humps_re.findall(name)) + 1 if name != matched: BenchmarkDoctor.log_naming.error( - "'%s' name doesn't conform to benchmark naming convention.", - name) - BenchmarkDoctor.log_naming.info( - 'See http://bit.ly/BenchmarkNaming') + "'%s' name doesn't conform to benchmark naming convention.", name + ) + BenchmarkDoctor.log_naming.info("See http://bit.ly/BenchmarkNaming") if composite_words > 4: BenchmarkDoctor.log_naming.warning( - "'%s' name is composed of %d words.", name, composite_words) + "'%s' name is composed of %d words.", name, composite_words + ) BenchmarkDoctor.log_naming.info( "Split '%s' name into dot-separated groups and variants. " - "See http://bit.ly/BenchmarkNaming", name) + "See http://bit.ly/BenchmarkNaming", + name, + ) @staticmethod def _name_is_at_most_40_chars_long(measurements): - name = measurements['name'] + name = measurements["name"] if len(name) > 40: BenchmarkDoctor.log_naming.error( - "'%s' name is %d characters long.", name, len(name)) + "'%s' name is %d characters long.", name, len(name) + ) BenchmarkDoctor.log_naming.info( - 'Benchmark name should not be longer than 40 characters.') + "Benchmark name should not be longer than 40 characters." + ) @staticmethod - def _select(measurements, num_iters=None, opt_level='O'): - prefix = measurements['name'] + ' ' + opt_level - prefix += '' if num_iters is None else (' i' + str(num_iters)) - return [series for name, series in measurements.items() - if name.startswith(prefix)] + def _select(measurements, num_iters=None, opt_level="O"): + prefix = measurements["name"] + " " + opt_level + prefix += "" if num_iters is None else (" i" + str(num_iters)) + return [ + series for name, series in measurements.items() if name.startswith(prefix) + ] @staticmethod def _optimized_runtime_in_range(measurements): - name = measurements['name'] + name = measurements["name"] setup, ratio = BenchmarkDoctor._setup_overhead(measurements) setup = 0 if ratio < 0.05 else setup runtime = min( - [(result.samples.min - correction) for i_series in - [BenchmarkDoctor._select(measurements, num_iters=i) - for correction in [(setup / i) for i in [1, 2]] - ] for result in i_series]) + [ + (result.samples.min - correction) + for i_series in [ + BenchmarkDoctor._select(measurements, num_iters=i) + for correction in [(setup / i) for i in [1, 2]] + ] + for result in i_series + ] + ) threshold = 1000 if threshold < runtime: - log = (BenchmarkDoctor.log_runtime.warning if runtime < 10000 else - BenchmarkDoctor.log_runtime.error) - caveat = '' if setup == 0 else ' (excluding the setup overhead)' + log = ( + BenchmarkDoctor.log_runtime.warning + if runtime < 10000 + else BenchmarkDoctor.log_runtime.error + ) + caveat = "" if setup == 0 else " (excluding the setup overhead)" log("'%s' execution took at least %d μs%s.", name, runtime, caveat) def factor(base): # suitable divisior that's integer power of base - return int(pow(base, math.ceil( - math.log(runtime / float(threshold), base)))) + return int( + pow(base, math.ceil(math.log(runtime / float(threshold), base))) + ) BenchmarkDoctor.log_runtime.info( "Decrease the workload of '%s' by a factor of %d (%d), to be " - "less than %d μs.", name, factor(2), factor(10), threshold) + "less than %d μs.", + name, + factor(2), + factor(10), + threshold, + ) threshold = 20 if runtime < threshold: - log = (BenchmarkDoctor.log_runtime.error if runtime == 0 else - BenchmarkDoctor.log_runtime.warning) + log = ( + BenchmarkDoctor.log_runtime.error + if runtime == 0 + else BenchmarkDoctor.log_runtime.warning + ) log("'%s' execution took %d μs.", name, runtime) BenchmarkDoctor.log_runtime.info( "Ensure the workload of '%s' has a properly measurable size" " (runtime > %d μs) and is not eliminated by the compiler (use" - " `blackHole` function if necessary)." if runtime == 0 else - "Increase the workload of '%s' to be more than %d μs.", - name, threshold) + " `blackHole` function if necessary)." + if runtime == 0 + else "Increase the workload of '%s' to be more than %d μs.", + name, + threshold, + ) @staticmethod def _setup_overhead(measurements): select = BenchmarkDoctor._select - ti1, ti2 = [float(min(mins)) for mins in - [[result.samples.min for result in i_series] - for i_series in - [select(measurements, num_iters=i) for i in [1, 2]]]] - setup = (int(round(2.0 * (ti1 - ti2))) if ti2 > 20 # limit of accuracy - else 0) + ti1, ti2 = [ + float(min(mins)) + for mins in [ + [result.samples.min for result in i_series] + for i_series in [select(measurements, num_iters=i) for i in [1, 2]] + ] + ] + setup = int(round(2.0 * (ti1 - ti2))) if ti2 > 20 else 0 # limit of accuracy ratio = (setup / ti1) if ti1 > 0 else 0 return (setup, ratio) @@ -466,52 +561,63 @@ class BenchmarkDoctor(object): if ratio > 0.05: BenchmarkDoctor.log_runtime.error( "'%s' has setup overhead of %d μs (%.1f%%).", - measurements['name'], setup, round((100 * ratio), 1)) + measurements["name"], + setup, + round((100 * ratio), 1), + ) BenchmarkDoctor.log_runtime.info( - 'Move initialization of benchmark data to the `setUpFunction` ' - 'registered in `BenchmarkInfo`.') + "Move initialization of benchmark data to the `setUpFunction` " + "registered in `BenchmarkInfo`." + ) @staticmethod def _reasonable_setup_time(measurements): - setup = min([result.setup - for result in BenchmarkDoctor._select(measurements)]) + setup = min([result.setup for result in BenchmarkDoctor._select(measurements)]) if 200000 < setup: # 200 ms BenchmarkDoctor.log_runtime.error( - "'%s' setup took at least %d μs.", - measurements['name'], setup) + "'%s' setup took at least %d μs.", measurements["name"], setup + ) BenchmarkDoctor.log_runtime.info( - 'The `setUpFunction` should take no more than 200 ms.') + "The `setUpFunction` should take no more than 200 ms." + ) @staticmethod def _constant_memory_use(measurements): select = BenchmarkDoctor._select (min_i1, max_i1), (min_i2, max_i2) = [ - (min(memory_use), max(memory_use)) for memory_use in - [[r.mem_pages for r in i_series] for i_series in - [select(measurements, num_iters=i) for i in - [1, 2]]]] + (min(memory_use), max(memory_use)) + for memory_use in [ + [r.mem_pages for r in i_series] + for i_series in [select(measurements, num_iters=i) for i in [1, 2]] + ] + ] range_i1, range_i2 = max_i1 - min_i1, max_i2 - min_i2 normal_range = 15 # pages - name = measurements['name'] + name = measurements["name"] more_info = False if abs(min_i1 - min_i2) > max(range_i1, range_i2, normal_range): more_info = True BenchmarkDoctor.log_memory.error( "'%s' varies the memory footprint of the base " - "workload depending on the `num-iters`.", name) + "workload depending on the `num-iters`.", + name, + ) if max(range_i1, range_i2) > normal_range: more_info = True BenchmarkDoctor.log_memory.warning( "'%s' has very wide range of memory used between " - "independent, repeated measurements.", name) + "independent, repeated measurements.", + name, + ) if more_info: BenchmarkDoctor.log_memory.info( "'%s' mem_pages [i1, i2]: min=[%d, %d] 𝚫=%d R=[%d, %d]", name, - *[min_i1, min_i2, abs(min_i1 - min_i2), range_i1, range_i2]) + *[min_i1, min_i2, abs(min_i1 - min_i2), range_i1, range_i2] + ) @staticmethod def _adjusted_1s_samples(runtime): @@ -530,38 +636,52 @@ class BenchmarkDoctor(object): Returns a dictionary with benchmark name and `PerformanceTestResult`s. """ - self.log.debug('Calibrating num-samples for {0}:'.format(benchmark)) - r = self.driver.run(benchmark, num_samples=3, num_iters=1, - verbose=True) # calibrate + self.log.debug("Calibrating num-samples for {0}:".format(benchmark)) + r = self.driver.run( + benchmark, num_samples=3, num_iters=1, verbose=True + ) # calibrate num_samples = self._adjusted_1s_samples(r.samples.min) def capped(s): return min(s, 200) + run_args = [(capped(num_samples), 1), (capped(num_samples / 2), 2)] opts = self.driver.args.optimization opts = opts if isinstance(opts, list) else [opts] self.log.debug( - 'Runtime {0} μs yields {1} adjusted samples per second.'.format( - r.samples.min, num_samples)) + "Runtime {0} μs yields {1} adjusted samples per second.".format( + r.samples.min, num_samples + ) + ) self.log.debug( - 'Measuring {0}, 5 x i1 ({1} samples), 5 x i2 ({2} samples)'.format( - benchmark, run_args[0][0], run_args[1][0])) + "Measuring {0}, 5 x i1 ({1} samples), 5 x i2 ({2} samples)".format( + benchmark, run_args[0][0], run_args[1][0] + ) + ) measurements = dict( - [('{0} {1} i{2}{3}'.format(benchmark, o, i, suffix), - self.driver.run(benchmark, num_samples=s, num_iters=i, - verbose=True, measure_memory=True)) - for o in opts - for s, i in run_args - for suffix in list('abcde') - ] + [ + ( + "{0} {1} i{2}{3}".format(benchmark, o, i, suffix), + self.driver.run( + benchmark, + num_samples=s, + num_iters=i, + verbose=True, + measure_memory=True, + ), + ) + for o in opts + for s, i in run_args + for suffix in list("abcde") + ] ) - measurements['name'] = benchmark + measurements["name"] = benchmark return measurements def analyze(self, benchmark_measurements): """Analyze whether benchmark fullfills all requirtements.""" - self.log.debug('Analyzing %s', benchmark_measurements['name']) + self.log.debug("Analyzing %s", benchmark_measurements["name"]) for rule in self.requirements: rule(benchmark_measurements) @@ -582,93 +702,137 @@ class BenchmarkDoctor(object): def format_name(log_path): """Return the filename and directory for a log file.""" - return '/'.join(log_path.split('/')[-2:]) + return "/".join(log_path.split("/")[-2:]) def compare_logs(compare_script, new_log, old_log, log_dir, opt): """Return diff of log files at paths `new_log` and `old_log`.""" - print('Comparing %s %s ...' % (format_name(old_log), format_name(new_log))) - subprocess.call([compare_script, '--old-file', old_log, - '--new-file', new_log, '--format', 'markdown', - '--output', os.path.join(log_dir, 'latest_compare_{0}.md' - .format(opt))]) + print("Comparing %s %s ..." % (format_name(old_log), format_name(new_log))) + subprocess.call( + [ + compare_script, + "--old-file", + old_log, + "--new-file", + new_log, + "--format", + "markdown", + "--output", + os.path.join(log_dir, "latest_compare_{0}.md".format(opt)), + ] + ) def compare(args): log_dir = args.log_dir compare_script = args.compare_script baseline_branch = args.baseline_branch - current_branch = \ - BenchmarkDriver(args, tests=[''])._git('rev-parse --abbrev-ref HEAD') + current_branch = BenchmarkDriver(args, tests=[""])._git( + "rev-parse --abbrev-ref HEAD" + ) current_branch_dir = os.path.join(log_dir, current_branch) baseline_branch_dir = os.path.join(log_dir, baseline_branch) - if current_branch != baseline_branch and \ - not os.path.isdir(baseline_branch_dir): - print(('Unable to find benchmark logs for {baseline_branch} branch. ' + - 'Set a baseline benchmark log by passing --benchmark to ' + - 'build-script while on {baseline_branch} branch.') - .format(baseline_branch=baseline_branch)) + if current_branch != baseline_branch and not os.path.isdir(baseline_branch_dir): + print( + ( + "Unable to find benchmark logs for {baseline_branch} branch. " + + "Set a baseline benchmark log by passing --benchmark to " + + "build-script while on {baseline_branch} branch." + ).format(baseline_branch=baseline_branch) + ) return 1 recent_logs = {} for branch_dir in [current_branch_dir, baseline_branch_dir]: - for opt in ['O', 'Onone']: - recent_logs[os.path.basename(branch_dir) + '_' + opt] = sorted( - glob.glob(os.path.join( - branch_dir, 'Benchmark_' + opt + '-*.log')), - key=os.path.getctime, reverse=True) + for opt in ["O", "Onone"]: + recent_logs[os.path.basename(branch_dir) + "_" + opt] = sorted( + glob.glob(os.path.join(branch_dir, "Benchmark_" + opt + "-*.log")), + key=os.path.getctime, + reverse=True, + ) if current_branch == baseline_branch: - if len(recent_logs[baseline_branch + '_O']) > 1 and \ - len(recent_logs[baseline_branch + '_Onone']) > 1: - compare_logs(compare_script, - recent_logs[baseline_branch + '_O'][0], - recent_logs[baseline_branch + '_O'][1], - log_dir, 'O') - compare_logs(compare_script, - recent_logs[baseline_branch + '_Onone'][0], - recent_logs[baseline_branch + '_Onone'][1], - log_dir, 'Onone') + if ( + len(recent_logs[baseline_branch + "_O"]) > 1 + and len(recent_logs[baseline_branch + "_Onone"]) > 1 + ): + compare_logs( + compare_script, + recent_logs[baseline_branch + "_O"][0], + recent_logs[baseline_branch + "_O"][1], + log_dir, + "O", + ) + compare_logs( + compare_script, + recent_logs[baseline_branch + "_Onone"][0], + recent_logs[baseline_branch + "_Onone"][1], + log_dir, + "Onone", + ) else: - print(('{baseline_branch}/{baseline_branch} comparison ' + - 'skipped: no previous {baseline_branch} logs') - .format(baseline_branch=baseline_branch)) + print( + ( + "{baseline_branch}/{baseline_branch} comparison " + + "skipped: no previous {baseline_branch} logs" + ).format(baseline_branch=baseline_branch) + ) else: # TODO: Check for outdated baseline branch log - if len(recent_logs[current_branch + '_O']) == 0 or \ - len(recent_logs[current_branch + '_Onone']) == 0: - print('branch sanity failure: missing branch logs') + if ( + len(recent_logs[current_branch + "_O"]) == 0 + or len(recent_logs[current_branch + "_Onone"]) == 0 + ): + print("branch sanity failure: missing branch logs") return 1 - if len(recent_logs[current_branch + '_O']) == 1 or \ - len(recent_logs[current_branch + '_Onone']) == 1: - print('branch/branch comparison skipped: no previous branch logs') + if ( + len(recent_logs[current_branch + "_O"]) == 1 + or len(recent_logs[current_branch + "_Onone"]) == 1 + ): + print("branch/branch comparison skipped: no previous branch logs") else: - compare_logs(compare_script, - recent_logs[current_branch + '_O'][0], - recent_logs[current_branch + '_O'][1], - log_dir, 'O') - compare_logs(compare_script, - recent_logs[current_branch + '_Onone'][0], - recent_logs[current_branch + '_Onone'][1], - log_dir, 'Onone') - - if len(recent_logs[baseline_branch + '_O']) == 0 or \ - len(recent_logs[baseline_branch + '_Onone']) == 0: - print(('branch/{baseline_branch} failure: no {baseline_branch} ' + - 'logs') - .format(baseline_branch=baseline_branch)) + compare_logs( + compare_script, + recent_logs[current_branch + "_O"][0], + recent_logs[current_branch + "_O"][1], + log_dir, + "O", + ) + compare_logs( + compare_script, + recent_logs[current_branch + "_Onone"][0], + recent_logs[current_branch + "_Onone"][1], + log_dir, + "Onone", + ) + + if ( + len(recent_logs[baseline_branch + "_O"]) == 0 + or len(recent_logs[baseline_branch + "_Onone"]) == 0 + ): + print( + ( + "branch/{baseline_branch} failure: no {baseline_branch} " + "logs" + ).format(baseline_branch=baseline_branch) + ) return 1 else: - compare_logs(compare_script, - recent_logs[current_branch + '_O'][0], - recent_logs[baseline_branch + '_O'][0], - log_dir, 'O') - compare_logs(compare_script, - recent_logs[current_branch + '_Onone'][0], - recent_logs[baseline_branch + '_Onone'][0], - log_dir, 'Onone') + compare_logs( + compare_script, + recent_logs[current_branch + "_O"][0], + recent_logs[baseline_branch + "_O"][0], + log_dir, + "O", + ) + compare_logs( + compare_script, + recent_logs[current_branch + "_Onone"][0], + recent_logs[baseline_branch + "_Onone"][0], + log_dir, + "Onone", + ) # TODO: Fail on large regressions @@ -686,79 +850,100 @@ def positive_int(value): def parse_args(args): """Parse command line arguments and set default values.""" parser = argparse.ArgumentParser( - epilog='Example: ./Benchmark_Driver run -i 5 -f Prefix -f .*Suffix.*' + epilog="Example: ./Benchmark_Driver run -i 5 -f Prefix -f .*Suffix.*" ) subparsers = parser.add_subparsers( - title='Swift benchmark driver commands', - help='See COMMAND -h for additional arguments', metavar='COMMAND') + title="Swift benchmark driver commands", + help="See COMMAND -h for additional arguments", + metavar="COMMAND", + ) shared_benchmarks_parser = argparse.ArgumentParser(add_help=False) benchmarks_group = shared_benchmarks_parser.add_mutually_exclusive_group() benchmarks_group.add_argument( - 'benchmarks', + "benchmarks", default=[], - help='benchmark to run (default: all)', nargs='*', metavar="BENCHMARK") + help="benchmark to run (default: all)", + nargs="*", + metavar="BENCHMARK", + ) benchmarks_group.add_argument( - '-f', '--filter', dest='filters', action='append', - help='run all tests whose name match regular expression PATTERN, ' + - 'multiple filters are supported', metavar="PATTERN") + "-f", + "--filter", + dest="filters", + action="append", + help="run all tests whose name match regular expression PATTERN, " + + "multiple filters are supported", + metavar="PATTERN", + ) shared_benchmarks_parser.add_argument( - '-t', '--tests', - help='directory containing Benchmark_O{,none,size} ' + - '(default: DRIVER_DIR)', - default=DRIVER_DIR) + "-t", + "--tests", + help="directory containing Benchmark_O{,none,size} " + "(default: DRIVER_DIR)", + default=DRIVER_DIR, + ) shared_benchmarks_parser.add_argument( - '-o', '--optimization', - metavar='OPT', - choices=['O', 'Onone', 'Osize'], - help='optimization level to use: {O,Onone,Osize}, (default: O)', - default='O') + "-o", + "--optimization", + metavar="OPT", + choices=["O", "Onone", "Osize"], + help="optimization level to use: {O,Onone,Osize}, (default: O)", + default="O", + ) run_parser = subparsers.add_parser( - 'run', - help='Run benchmarks and output results to stdout', - parents=[shared_benchmarks_parser]) + "run", + help="Run benchmarks and output results to stdout", + parents=[shared_benchmarks_parser], + ) run_parser.add_argument( - '-i', '--independent-samples', - help='number of times to run each test (default: 1)', - type=positive_int, default=1) + "-i", + "--independent-samples", + help="number of times to run each test (default: 1)", + type=positive_int, + default=1, + ) run_parser.add_argument( - '--output-dir', - help='log results to directory (default: no logging)') + "--output-dir", help="log results to directory (default: no logging)" + ) run_parser.add_argument( - '--swift-repo', - help='absolute path to the Swift source repository') + "--swift-repo", help="absolute path to the Swift source repository" + ) run_parser.set_defaults(func=BenchmarkDriver.run_benchmarks) check_parser = subparsers.add_parser( - 'check', - help='', - parents=[shared_benchmarks_parser]) + "check", help="", parents=[shared_benchmarks_parser] + ) check_group = check_parser.add_mutually_exclusive_group() check_group.add_argument( - '-v', '--verbose', action='store_true', - help='show more details during benchmark analysis') + "-v", + "--verbose", + action="store_true", + help="show more details during benchmark analysis", + ) check_group.add_argument( - '-md', '--markdown', action='store_true', - help='format report as Markdown table') + "-md", "--markdown", action="store_true", help="format report as Markdown table" + ) check_parser.set_defaults(func=BenchmarkDoctor.run_check) - compare_parser = subparsers.add_parser( - 'compare', - help='Compare benchmark results') + compare_parser = subparsers.add_parser("compare", help="Compare benchmark results") compare_parser.add_argument( - '--log-dir', required=True, - help='directory containing benchmark logs') + "--log-dir", required=True, help="directory containing benchmark logs" + ) compare_parser.add_argument( - '--swift-repo', required=True, - help='absolute path to the Swift source repository') + "--swift-repo", + required=True, + help="absolute path to the Swift source repository", + ) compare_parser.add_argument( - '--compare-script', required=True, - help='absolute path to compare script') + "--compare-script", required=True, help="absolute path to compare script" + ) compare_parser.add_argument( - '--baseline-branch', default='master', - help='attempt to compare results to baseline results for specified ' - 'branch (default: master)') + "--baseline-branch", + default="master", + help="attempt to compare results to baseline results for specified " + "branch (default: master)", + ) compare_parser.set_defaults(func=compare) return parser.parse_args(args) @@ -770,5 +955,5 @@ def main(): return args.func(args) -if __name__ == '__main__': +if __name__ == "__main__": exit(main()) diff --git a/benchmark/scripts/Benchmark_GuardMalloc.in b/benchmark/scripts/Benchmark_GuardMalloc.in index e7d001d4bfa1d..872179e1d28de 100644 --- a/benchmark/scripts/Benchmark_GuardMalloc.in +++ b/benchmark/scripts/Benchmark_GuardMalloc.in @@ -21,37 +21,36 @@ sys.path.append("@PATH_TO_DRIVER_LIBRARY@") import perf_test_driver # noqa (E402 module level import not at top of file) # Regexes for the XFAIL_LIST. Matches against '([Onone|O|Osize],TestName)' -XFAIL_LIST = [ -] +XFAIL_LIST = [] class GuardMallocResult(perf_test_driver.Result): - def __init__(self, name, status): perf_test_driver.Result.__init__(self, name, status, "", XFAIL_LIST) class GuardMallocBenchmarkDriver(perf_test_driver.BenchmarkDriver): - def __init__(self, binary, xfail_list): perf_test_driver.BenchmarkDriver.__init__( - self, binary, xfail_list, - enable_parallel=True) + self, binary, xfail_list, enable_parallel=True + ) self.new_env = os.environ.copy() - self.new_env['DYLD_INSERT_LIBRARIES'] = '/usr/lib/libgmalloc.dylib' + self.new_env["DYLD_INSERT_LIBRARIES"] = "/usr/lib/libgmalloc.dylib" def prepare_input(self, name): - return {'env': self.new_env} + return {"env": self.new_env} def process_input(self, data): - test_name = '({},{})'.format(data['opt'], data['test_name']) + test_name = "({},{})".format(data["opt"], data["test_name"]) print("Running {}...".format(test_name)) sys.stdout.flush() p = subprocess.Popen( - [data['path'], data['test_name'], '--num-iters=2'], - env=data['env'], stderr=open('/dev/null', 'w'), - stdout=open('/dev/null', 'w')) + [data["path"], data["test_name"], "--num-iters=2"], + env=data["env"], + stderr=open("/dev/null", "w"), + stdout=open("/dev/null", "w"), + ) status = p.wait() return GuardMallocResult(test_name, status) diff --git a/benchmark/scripts/Benchmark_QuickCheck.in b/benchmark/scripts/Benchmark_QuickCheck.in index 0599d9eb2c8d5..a2cc257476240 100644 --- a/benchmark/scripts/Benchmark_QuickCheck.in +++ b/benchmark/scripts/Benchmark_QuickCheck.in @@ -12,7 +12,6 @@ # # ===---------------------------------------------------------------------===// -import json import os import subprocess import sys @@ -23,47 +22,48 @@ import perf_test_driver # noqa (E402 module level import not at top of file) # This is a hacked up XFAIL list. It should really be a json file, but it will # work for now. Add in the exact name of the pass to XFAIL. -XFAIL_LIST = [ -] +XFAIL_LIST = [] class QuickCheckResult(perf_test_driver.Result): - def __init__(self, name, success): - assert(isinstance(success, bool)) + assert isinstance(success, bool) did_fail = not success perf_test_driver.Result.__init__(self, name, did_fail, "", XFAIL_LIST) def print_data(self, max_test_len): - fmt = '{:<%d}{:<10}' % (max_test_len + 5) + fmt = "{:<%d}{:<10}" % (max_test_len + 5) print(fmt.format(self.get_name(), self.get_result())) class QuickCheckBenchmarkDriver(perf_test_driver.BenchmarkDriver): - def __init__(self, binary, xfail_list, num_iters, opt_levels): perf_test_driver.BenchmarkDriver.__init__( - self, binary, xfail_list, - enable_parallel=True, - opt_levels=opt_levels) + self, binary, xfail_list, enable_parallel=True, opt_levels=opt_levels + ) self.num_iters = num_iters def print_data_header(self, max_test_len): - fmt = '{:<%d}{:<10}' % (max_test_len + 5) - print(fmt.format('Name', 'Result')) + fmt = "{:<%d}{:<10}" % (max_test_len + 5) + print(fmt.format("Name", "Result")) # Propagate any data from this class that is needed for individual # tests. The reason this is needed is to avoid issues with attempting to # access a value in a different process. def prepare_input(self, name): - return {'num_samples': 1, 'num_iters': self.num_iters} + return {"num_samples": 1, "num_iters": self.num_iters} def run_test_inner(self, data, num_iters): - p = subprocess.Popen([ - data['path'], - "--num-samples={}".format(data['num_samples']), - "--num-iters={}".format(num_iters), data['test_name']], - stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p = subprocess.Popen( + [ + data["path"], + "--num-samples={}".format(data["num_samples"]), + "--num-iters={}".format(num_iters), + data["test_name"], + ], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) error_out = p.communicate()[1].split("\n") result = p.returncode if result is None: @@ -75,20 +75,21 @@ class QuickCheckBenchmarkDriver(perf_test_driver.BenchmarkDriver): def run_test(self, data, num_iters): try: args = [data, num_iters] - result = perf_test_driver.run_with_timeout(self.run_test_inner, - args) + perf_test_driver.run_with_timeout(self.run_test_inner, args) except Exception, e: - sys.stderr.write("Child Process Failed! (%s,%s). Error: %s\n" % ( - data['path'], data['test_name'], e)) + sys.stderr.write( + "Child Process Failed! (%s,%s). Error: %s\n" + % (data["path"], data["test_name"], e) + ) sys.stderr.flush() return None return True def process_input(self, data): - test_name = '({},{})'.format(data['opt'], data['test_name']) + test_name = "({},{})".format(data["opt"], data["test_name"]) print("Running {}...".format(test_name)) sys.stdout.flush() - if self.run_test(data, data['num_iters']) is None: + if self.run_test(data, data["num_iters"]) is None: return QuickCheckResult(test_name, success=False) return QuickCheckResult(test_name, success=True) @@ -98,13 +99,17 @@ SWIFT_BIN_DIR = os.path.dirname(os.path.abspath(__file__)) def parse_args(): import argparse + parser = argparse.ArgumentParser() parser.add_argument( - '--filter', type=str, default=None, - help='Filter out any test that does not match the given regex') - parser.add_argument('--num-iters', type=int, default=2) + "--filter", + type=str, + default=None, + help="Filter out any test that does not match the given regex", + ) + parser.add_argument("--num-iters", type=int, default=2) default_opt_levels = perf_test_driver.BenchmarkDriver_OptLevels - parser.add_argument('--opt-level', choices=default_opt_levels) + parser.add_argument("--opt-level", choices=default_opt_levels) return parser.parse_args() @@ -113,9 +118,10 @@ if __name__ == "__main__": opt_levels = perf_test_driver.BenchmarkDriver_OptLevels if args.opt_level is not None: opt_levels = [args.opt_level] - l = QuickCheckBenchmarkDriver(SWIFT_BIN_DIR, XFAIL_LIST, args.num_iters, - opt_levels) - if l.run(args.filter): + driver = QuickCheckBenchmarkDriver( + SWIFT_BIN_DIR, XFAIL_LIST, args.num_iters, opt_levels + ) + if driver.run(args.filter): sys.exit(0) else: sys.exit(-1) diff --git a/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in b/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in index 2a7dd0d81d986..756af2348c6b5 100644 --- a/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in +++ b/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in @@ -23,26 +23,26 @@ import perf_test_driver # noqa (E402 module level import not at top of file) # This is a hacked up XFAIL list. It should really be a json file, but it will # work for now. Add in the exact name of the pass to XFAIL. -XFAIL_LIST = [ -] +XFAIL_LIST = [] # Global Objective-C classes created by various frameworks. We do not care # about these. -IGNORABLE_GLOBAL_OBJC_CLASSES = set([ - '__NSPlaceholderDate', - 'NSCache', - '__NSPlaceholderTimeZone', - 'NSPlaceholderNumber', - 'NSPlaceholderString', - '__NSPlaceholderArray', - '__NSPlaceholderDictionary', - '_NSPlaceholderData', - '_NSJSONReader' -]) +IGNORABLE_GLOBAL_OBJC_CLASSES = set( + [ + "__NSPlaceholderDate", + "NSCache", + "__NSPlaceholderTimeZone", + "NSPlaceholderNumber", + "NSPlaceholderString", + "__NSPlaceholderArray", + "__NSPlaceholderDictionary", + "_NSPlaceholderData", + "_NSJSONReader", + ] +) class LeaksRunnerResult(perf_test_driver.Result): - def __init__(self, name, count=None): # True = 1, False = 0. # @@ -57,36 +57,39 @@ class LeaksRunnerResult(perf_test_driver.Result): return "N/A" def print_data(self, max_test_len): - fmt = '{:<%d}{:<10}{:}' % (max_test_len + 5) - print(fmt.format(self.get_name(), self.get_result(), - self.get_count())) + fmt = "{:<%d}{:<10}{:}" % (max_test_len + 5) + print(fmt.format(self.get_name(), self.get_result(), self.get_count())) class LeaksRunnerBenchmarkDriver(perf_test_driver.BenchmarkDriver): - def __init__(self, binary, xfail_list, num_samples, num_iters): perf_test_driver.BenchmarkDriver.__init__( - self, binary, xfail_list, - enable_parallel=True) + self, binary, xfail_list, enable_parallel=True + ) self.num_samples = num_samples self.num_iters = num_iters def print_data_header(self, max_test_len): - fmt = '{:<%d}{:<10}{:}' % (max_test_len + 5) - print(fmt.format('Name', 'Result', 'RC Delta')) + fmt = "{:<%d}{:<10}{:}" % (max_test_len + 5) + print(fmt.format("Name", "Result", "RC Delta")) # Propagate any data from this class that is needed for individual # tests. The reason this is needed is to avoid issues with attempting to # access a value in a different process. def prepare_input(self, name): - return {'num_samples': self.num_samples, 'num_iters': self.num_iters} + return {"num_samples": self.num_samples, "num_iters": self.num_iters} def run_test_inner(self, data, num_iters): - p = subprocess.Popen([ - data['path'], - "--num-samples={}".format(data['num_samples']), - "--num-iters={}".format(num_iters), data['test_name']], - stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p = subprocess.Popen( + [ + data["path"], + "--num-samples={}".format(data["num_samples"]), + "--num-iters={}".format(num_iters), + data["test_name"], + ], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) error_out = p.communicate()[1].split("\n") result = p.returncode if result is None: @@ -98,11 +101,12 @@ class LeaksRunnerBenchmarkDriver(perf_test_driver.BenchmarkDriver): def run_test(self, data, num_iters): try: args = [data, num_iters] - result = perf_test_driver.run_with_timeout(self.run_test_inner, - args) + result = perf_test_driver.run_with_timeout(self.run_test_inner, args) except Exception, e: - sys.stderr.write("Child Process Failed! (%s,%s). Error: %s\n" % ( - data['path'], data['test_name'], e)) + sys.stderr.write( + "Child Process Failed! (%s,%s). Error: %s\n" + % (data["path"], data["test_name"], e) + ) sys.stderr.flush() return None @@ -110,26 +114,27 @@ class LeaksRunnerBenchmarkDriver(perf_test_driver.BenchmarkDriver): # We grab the second line since swift globals get lazily created in # the first iteration. d = json.loads(result[1]) - d['objc_objects'] = [x for x in d['objc_objects'] - if x not in IGNORABLE_GLOBAL_OBJC_CLASSES] - d['objc_count'] = len(d['objc_objects']) + d["objc_objects"] = [ + x for x in d["objc_objects"] if x not in IGNORABLE_GLOBAL_OBJC_CLASSES + ] + d["objc_count"] = len(d["objc_objects"]) - total_count = d['objc_count'] + d['swift_count'] + total_count = d["objc_count"] + d["swift_count"] return total_count except Exception: - tmp = (data['path'], data['test_name']) + tmp = (data["path"], data["test_name"]) sys.stderr.write("Failed parse output! (%s,%s)\n" % tmp) sys.stderr.flush() return None def process_input(self, data): - test_name = '({},{})'.format(data['opt'], data['test_name']) + test_name = "({},{})".format(data["opt"], data["test_name"]) print("Running {}...".format(test_name)) sys.stdout.flush() - total_count1 = self.run_test(data, data['num_iters']) + total_count1 = self.run_test(data, data["num_iters"]) if total_count1 is None: return LeaksRunnerResult(test_name) - total_count2 = self.run_test(data, data['num_iters'] + 1) + total_count2 = self.run_test(data, data["num_iters"] + 1) if total_count2 is None: return LeaksRunnerResult(test_name) return LeaksRunnerResult(test_name, total_count2 - total_count1) @@ -140,19 +145,24 @@ SWIFT_BIN_DIR = os.path.dirname(os.path.abspath(__file__)) def parse_args(): import argparse + parser = argparse.ArgumentParser() parser.add_argument( - '-filter', type=str, default=None, - help='Filter out any test that does not match the given regex') - parser.add_argument('-num-samples', type=int, default=2) - parser.add_argument('-num-iters', type=int, default=2) + "-filter", + type=str, + default=None, + help="Filter out any test that does not match the given regex", + ) + parser.add_argument("-num-samples", type=int, default=2) + parser.add_argument("-num-iters", type=int, default=2) return parser.parse_args() if __name__ == "__main__": args = parse_args() driver = LeaksRunnerBenchmarkDriver( - SWIFT_BIN_DIR, XFAIL_LIST, args.num_samples, args.num_iters) + SWIFT_BIN_DIR, XFAIL_LIST, args.num_samples, args.num_iters + ) if driver.run(args.filter): sys.exit(0) else: diff --git a/benchmark/scripts/build_linux.py b/benchmark/scripts/build_linux.py index 64bee4692bbb1..4404815931182 100755 --- a/benchmark/scripts/build_linux.py +++ b/benchmark/scripts/build_linux.py @@ -7,39 +7,45 @@ def main(): p = argparse.ArgumentParser() - p.add_argument('cmake_path', help='The cmake binary to use') - p.add_argument('swift_src_dir', help='The swift source directory') - p.add_argument('clang', help='The path to the clang binary to use') - p.add_argument('swift_root_dir', - help='A path to a swift root produced by installing ' - 'Swift and Foundation together. We infer swiftc ' - 'from here') - p.add_argument('destdir', help='The directory to perform the actual ' - 'build in') - p.add_argument('--clean', action='store_true', - help='Delete destdir before performing a build.') + p.add_argument("cmake_path", help="The cmake binary to use") + p.add_argument("swift_src_dir", help="The swift source directory") + p.add_argument("clang", help="The path to the clang binary to use") + p.add_argument( + "swift_root_dir", + help="A path to a swift root produced by installing " + "Swift and Foundation together. We infer swiftc " + "from here", + ) + p.add_argument("destdir", help="The directory to perform the actual " "build in") + p.add_argument( + "--clean", action="store_true", help="Delete destdir before performing a build." + ) args = p.parse_args() if args.clean: print("Asked to clean... Cleaning!") - subprocess.check_output(['/bin/rm', '-rfv', args.destdir]) - subprocess.check_call(['/bin/mkdir', '-p', args.destdir]) + subprocess.check_output(["/bin/rm", "-rfv", args.destdir]) + subprocess.check_call(["/bin/mkdir", "-p", args.destdir]) os.chdir(args.destdir) configureInvocation = [ - args.cmake_path, '-GNinja', - '-DSWIFT_EXEC={}/bin/swiftc'.format(args.swift_root_dir), - '-DCLANG_EXEC={}'.format(args.clang), - '-DSWIFT_LIBRARY_PATH={}/lib/swift'.format(args.swift_root_dir), - '{}/benchmark'.format(args.swift_src_dir) + args.cmake_path, + "-GNinja", + "-DSWIFT_EXEC={}/bin/swiftc".format(args.swift_root_dir), + "-DCLANG_EXEC={}".format(args.clang), + "-DSWIFT_LIBRARY_PATH={}/lib/swift".format(args.swift_root_dir), + "{}/benchmark".format(args.swift_src_dir), ] - print('COMMAND: {}'.format(' '.join(configureInvocation))) + print("COMMAND: {}".format(" ".join(configureInvocation))) subprocess.check_call(configureInvocation) buildInvocation = [ - args.cmake_path, '--build', args.destdir, '--', - 'swift-benchmark-linux-x86_64' + args.cmake_path, + "--build", + args.destdir, + "--", + "swift-benchmark-linux-x86_64", ] - print('COMMAND: {}'.format(' '.join(buildInvocation))) + print("COMMAND: {}".format(" ".join(buildInvocation))) subprocess.check_call(buildInvocation) diff --git a/benchmark/scripts/build_script_helper.py b/benchmark/scripts/build_script_helper.py index a3f999042289f..53bf7b19f6862 100755 --- a/benchmark/scripts/build_script_helper.py +++ b/benchmark/scripts/build_script_helper.py @@ -9,50 +9,54 @@ def perform_build(args, swiftbuild_path, config, binary_name, opt_flag): - assert(config in ['debug', 'release']) - assert(binary_name in ['Benchmark_O', 'Benchmark_Osize', - 'Benchmark_Onone']) - assert(opt_flag in ['-O', '-Osize', '-Onone']) + assert config in ["debug", "release"] + assert binary_name in ["Benchmark_O", "Benchmark_Osize", "Benchmark_Onone"] + assert opt_flag in ["-O", "-Osize", "-Onone"] inner_build_dir = os.path.join(args.build_path, binary_name) swiftbuild_args = [ swiftbuild_path, - '--package-path', args.package_path, - '--build-path', inner_build_dir, - '--configuration', config, - '-Xswiftc', '-Xllvm', - '-Xswiftc', '-align-module-to-page-size', - '-Xswiftc', opt_flag, + "--package-path", + args.package_path, + "--build-path", + inner_build_dir, + "--configuration", + config, + "-Xswiftc", + "-Xllvm", + "-Xswiftc", + "-align-module-to-page-size", + "-Xswiftc", + opt_flag, ] if args.verbose: - swiftbuild_args.append('--verbose') + swiftbuild_args.append("--verbose") subprocess.call(swiftbuild_args) # Copy the benchmark file into the final ./bin directory. - binpath = os.path.join(inner_build_dir, config, 'SwiftBench') - finalpath = os.path.join(args.build_path, 'bin', binary_name) + binpath = os.path.join(inner_build_dir, config, "SwiftBench") + finalpath = os.path.join(args.build_path, "bin", binary_name) shutil.copy(binpath, finalpath) def main(): parser = argparse.ArgumentParser() - parser.add_argument('--verbose', '-v', action='store_true') - parser.add_argument('--package-path', type=str, required=True) - parser.add_argument('--build-path', type=str, required=True) - parser.add_argument('--toolchain', type=str, required=True) + parser.add_argument("--verbose", "-v", action="store_true") + parser.add_argument("--package-path", type=str, required=True) + parser.add_argument("--build-path", type=str, required=True) + parser.add_argument("--toolchain", type=str, required=True) args = parser.parse_args() # Create our bin directory so we can copy in the binaries. - bin_dir = os.path.join(args.build_path, 'bin') + bin_dir = os.path.join(args.build_path, "bin") if not os.path.isdir(bin_dir): os.makedirs(bin_dir) - swiftbuild_path = os.path.join(args.toolchain, 'usr', 'bin', 'swift-build') - perform_build(args, swiftbuild_path, 'debug', 'Benchmark_Onone', '-Onone') - perform_build(args, swiftbuild_path, 'release', 'Benchmark_Osize', - '-Osize') - perform_build(args, swiftbuild_path, 'release', 'Benchmark_O', '-O') + swiftbuild_path = os.path.join(args.toolchain, "usr", "bin", "swift-build") + perform_build(args, swiftbuild_path, "debug", "Benchmark_Onone", "-Onone") + perform_build(args, swiftbuild_path, "release", "Benchmark_Osize", "-Osize") + perform_build(args, swiftbuild_path, "release", "Benchmark_O", "-O") if __name__ == "__main__": diff --git a/benchmark/scripts/compare_perf_tests.py b/benchmark/scripts/compare_perf_tests.py index 017ba24c10229..69450cb4b97b5 100755 --- a/benchmark/scripts/compare_perf_tests.py +++ b/benchmark/scripts/compare_perf_tests.py @@ -37,7 +37,7 @@ class `ReportFormatter` creates the test comparison report in specified format. from math import ceil, sqrt -class Sample(namedtuple('Sample', 'i num_iters runtime')): +class Sample(namedtuple("Sample", "i num_iters runtime")): u"""Single benchmark measurement. Initialized with: @@ -48,10 +48,10 @@ class Sample(namedtuple('Sample', 'i num_iters runtime')): def __repr__(self): """Shorter Sample formating for debugging purposes.""" - return 's({0.i!r}, {0.num_iters!r}, {0.runtime!r})'.format(self) + return "s({0.i!r}, {0.num_iters!r}, {0.runtime!r})".format(self) -class Yield(namedtuple('Yield', 'before_sample after')): +class Yield(namedtuple("Yield", "before_sample after")): u"""Meta-measurement of when the Benchmark_X voluntarily yielded process. `before_sample`: index of measurement taken just after returning from yield @@ -79,13 +79,14 @@ def __init__(self, name, samples=None): def __str__(self): """Text summary of benchmark statistics.""" return ( - '{0.name!s} n={0.count!r} ' - 'Min={0.min!r} Q1={0.q1!r} M={0.median!r} Q3={0.q3!r} ' - 'Max={0.max!r} ' - 'R={0.range!r} {0.spread:.2%} IQR={0.iqr!r} ' - 'Mean={0.mean:.0f} SD={0.sd:.0f} CV={0.cv:.2%}' - .format(self) if self.samples else - '{0.name!s} n=0'.format(self)) + "{0.name!s} n={0.count!r} " + "Min={0.min!r} Q1={0.q1!r} M={0.median!r} Q3={0.q3!r} " + "Max={0.max!r} " + "R={0.range!r} {0.spread:.2%} IQR={0.iqr!r} " + "Mean={0.mean:.0f} SD={0.sd:.0f} CV={0.cv:.2%}".format(self) + if self.samples + else "{0.name!s} n=0".format(self) + ) def add(self, sample): """Add sample to collection and recompute statistics.""" @@ -97,8 +98,9 @@ def add(self, sample): def _update_stats(self, sample): old_stats = (self.count, self.mean, self.S_runtime) - _, self.mean, self.S_runtime = ( - self.running_mean_variance(old_stats, sample.runtime)) + _, self.mean, self.S_runtime = self.running_mean_variance( + old_stats, sample.runtime + ) def exclude_outliers(self, top_only=False): """Exclude outliers by applying Interquartile Range Rule. @@ -112,8 +114,11 @@ def exclude_outliers(self, top_only=False): benchmark runtimes in the microbenchmark range to filter out the environment noise caused by preemtive multitasking. """ - lo = (0 if top_only else - bisect_left(self._runtimes, int(self.q1 - 1.5 * self.iqr))) + lo = ( + 0 + if top_only + else bisect_left(self._runtimes, int(self.q1 - 1.5 * self.iqr)) + ) hi = bisect_right(self._runtimes, int(self.q3 + 1.5 * self.iqr)) outliers = self.samples[:lo] + self.samples[hi:] @@ -181,8 +186,7 @@ def iqr(self): @property def sd(self): u"""Standard Deviation (μs).""" - return (0 if self.count < 2 else - sqrt(self.S_runtime / (self.count - 1))) + return 0 if self.count < 2 else sqrt(self.S_runtime / (self.count - 1)) @staticmethod def running_mean_variance((k, M_, S_), x): @@ -229,14 +233,13 @@ class PerformanceTestResult(object): `--quantile`parameter. In both cases, the last column, MAX_RSS is optional. """ - def __init__(self, csv_row, quantiles=False, memory=False, delta=False, - meta=False): + def __init__(self, csv_row, quantiles=False, memory=False, delta=False, meta=False): """Initialize from a row of multiple columns with benchmark summary. The row is an iterable, such as a row provided by the CSV parser. """ - self.test_num = csv_row[0] # Ordinal number of the test - self.name = csv_row[1] # Name of the performance test + self.test_num = csv_row[0] # Ordinal number of the test + self.name = csv_row[1] # Name of the performance test self.num_samples = int(csv_row[2]) # Number of measurements taken if quantiles: # Variable number of columns representing quantiles @@ -244,50 +247,63 @@ def __init__(self, csv_row, quantiles=False, memory=False, delta=False, runtimes = csv_row[3:mem_index] if memory or meta else csv_row[3:] if delta: runtimes = [int(x) if x else 0 for x in runtimes] - runtimes = reduce(lambda l, x: l.append(l[-1] + x) or # runnin - l if l else [x], runtimes, None) # total + runtimes = reduce( + lambda l, x: l.append(l[-1] + x) or l if l else [x], # runnin + runtimes, + None, + ) # total num_values = len(runtimes) if self.num_samples < num_values: # remove repeated samples quantile = num_values - 1 qs = [float(i) / float(quantile) for i in range(0, num_values)] - indices = [max(0, int(ceil(self.num_samples * float(q))) - 1) - for q in qs] - runtimes = [runtimes[indices.index(i)] - for i in range(0, self.num_samples)] + indices = [ + max(0, int(ceil(self.num_samples * float(q))) - 1) for q in qs + ] + runtimes = [ + runtimes[indices.index(i)] for i in range(0, self.num_samples) + ] self.samples = PerformanceTestSamples( - self.name, - [Sample(None, None, int(runtime)) for runtime in runtimes]) + self.name, [Sample(None, None, int(runtime)) for runtime in runtimes] + ) self.samples.exclude_outliers(top_only=True) sams = self.samples - self.min, self.max, self.median, self.mean, self.sd = \ - sams.min, sams.max, sams.median, sams.mean, sams.sd - self.max_rss = ( # Maximum Resident Set Size (B) - int(csv_row[mem_index]) if memory else None) + self.min, self.max, self.median, self.mean, self.sd = ( + sams.min, + sams.max, + sams.median, + sams.mean, + sams.sd, + ) + self.max_rss = ( # Maximum Resident Set Size (B) + int(csv_row[mem_index]) if memory else None + ) else: # Legacy format with statistics for normal distribution. - self.min = int(csv_row[3]) # Minimum runtime (μs) - self.max = int(csv_row[4]) # Maximum runtime (μs) - self.mean = float(csv_row[5]) # Mean (average) runtime (μs) - self.sd = float(csv_row[6]) # Standard Deviation (μs) - self.median = int(csv_row[7]) # Median runtime (μs) - self.max_rss = ( # Maximum Resident Set Size (B) - int(csv_row[8]) if len(csv_row) > 8 else None) + self.min = int(csv_row[3]) # Minimum runtime (μs) + self.max = int(csv_row[4]) # Maximum runtime (μs) + self.mean = float(csv_row[5]) # Mean (average) runtime (μs) + self.sd = float(csv_row[6]) # Standard Deviation (μs) + self.median = int(csv_row[7]) # Median runtime (μs) + self.max_rss = ( # Maximum Resident Set Size (B) + int(csv_row[8]) if len(csv_row) > 8 else None + ) self.samples = None # Optional measurement metadata. The number of: # memory pages used, involuntary context switches and voluntary yields - self.mem_pages, self.involuntary_cs, self.yield_count = \ + self.mem_pages, self.involuntary_cs, self.yield_count = ( [int(x) for x in csv_row[-3:]] if meta else (None, None, None) + ) self.yields = None self.setup = None def __repr__(self): """Short summary for debugging purposes.""" return ( - '' - .format(self)) + "".format(self) + ) def merge(self, r): """Merge two results. @@ -302,8 +318,13 @@ def merge(self, r): map(self.samples.add, r.samples.samples) sams = self.samples self.num_samples = sams.num_samples - self.min, self.max, self.median, self.mean, self.sd = \ - sams.min, sams.max, sams.median, sams.mean, sams.sd + self.min, self.max, self.median, self.mean, self.sd = ( + sams.min, + sams.max, + sams.median, + sams.mean, + sams.sd, + ) else: self.min = min(self.min, r.min) self.max = max(self.max, r.max) @@ -315,8 +336,8 @@ def merge(self, r): # Metadata def minimum(a, b): # work around None being less than everything - return (min(filter(lambda x: x is not None, [a, b])) if any([a, b]) - else None) + return min(filter(lambda x: x is not None, [a, b])) if any([a, b]) else None + self.max_rss = minimum(self.max_rss, r.max_rss) self.setup = minimum(self.setup, r.setup) @@ -339,12 +360,13 @@ def __init__(self, old, new): # Test runtime improvement in % ratio = (new.min + 0.001) / (old.min + 0.001) - self.delta = ((ratio - 1) * 100) + self.delta = (ratio - 1) * 100 # Indication of dubious changes: when result's MIN falls inside the # (MIN, MAX) interval of result they are being compared with. - self.is_dubious = ((old.min < new.min and new.min < old.max) or - (new.min < old.min and old.min < new.max)) + self.is_dubious = (old.min < new.min and new.min < old.max) or ( + new.min < old.min and old.min < new.max + ) class LogParser(object): @@ -371,15 +393,20 @@ def _reset(self): # Parse lines like this # #,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs) results_re = re.compile( - r'( *\d+[, \t]+[\w.\-\?!]+[, \t]+' + # #,TEST - r'[, \t]+'.join([r'\d+'] * 2) + # at least 2... - r'(?:[, \t]+\d*)*)') # ...or more numeric columns + r"( *\d+[, \t]+[\w.\-\?!]+[, \t]+" + + r"[, \t]+".join([r"\d+"] * 2) # #,TEST + + r"(?:[, \t]+\d*)*)" # at least 2... + ) # ...or more numeric columns def _append_result(self, result): - columns = result.split(',') if ',' in result else result.split() + columns = result.split(",") if "," in result else result.split() r = PerformanceTestResult( - columns, quantiles=self.quantiles, memory=self.memory, - delta=self.delta, meta=self.meta) + columns, + quantiles=self.quantiles, + memory=self.memory, + delta=self.delta, + meta=self.meta, + ) r.setup = self.setup r.max_rss = r.max_rss or self.max_rss r.mem_pages = r.mem_pages or self.mem_pages @@ -397,45 +424,43 @@ def _store_memory_stats(self, max_rss, mem_pages): self.mem_pages = int(mem_pages) def _configure_format(self, header): - self.quantiles = 'MEAN' not in header - self.memory = 'MAX_RSS' in header - self.meta = 'PAGES' in header - self.delta = '𝚫' in header + self.quantiles = "MEAN" not in header + self.memory = "MAX_RSS" in header + self.meta = "PAGES" in header + self.delta = "𝚫" in header # Regular expression and action to take when it matches the parsed line state_actions = { results_re: _append_result, - # Verbose mode adds new productions: # Adaptively determined N; test loop multiple adjusting runtime to ~1s - re.compile(r'\s+Measuring with scale (\d+).'): - (lambda self, num_iters: setattr(self, 'num_iters', num_iters)), - - re.compile(r'\s+Sample (\d+),(\d+)'): - (lambda self, i, runtime: - self.samples.append( - Sample(int(i), int(self.num_iters), int(runtime)))), - - re.compile(r'\s+SetUp (\d+)'): - (lambda self, setup: setattr(self, 'setup', int(setup))), - - re.compile(r'\s+Yielding after ~(\d+) μs'): - (lambda self, since_last_yield: - self.yields.append( - Yield(len(self.samples), int(since_last_yield)))), - - re.compile(r'( *#[, \t]+TEST[, \t]+SAMPLES[, \t]+MIN.*)'): - _configure_format, - + re.compile(r"\s+Measuring with scale (\d+)."): ( + lambda self, num_iters: setattr(self, "num_iters", num_iters) + ), + re.compile(r"\s+Sample (\d+),(\d+)"): ( + lambda self, i, runtime: self.samples.append( + Sample(int(i), int(self.num_iters), int(runtime)) + ) + ), + re.compile(r"\s+SetUp (\d+)"): ( + lambda self, setup: setattr(self, "setup", int(setup)) + ), + re.compile(r"\s+Yielding after ~(\d+) μs"): ( + lambda self, since_last_yield: self.yields.append( + Yield(len(self.samples), int(since_last_yield)) + ) + ), + re.compile(r"( *#[, \t]+TEST[, \t]+SAMPLES[, \t]+MIN.*)"): _configure_format, # Environmental statistics: memory usage and context switches - re.compile(r'\s+MAX_RSS \d+ - \d+ = (\d+) \((\d+) pages\)'): - _store_memory_stats, - - re.compile(r'\s+VCS \d+ - \d+ = (\d+)'): - (lambda self, vcs: setattr(self, 'voluntary_cs', int(vcs))), - - re.compile(r'\s+ICS \d+ - \d+ = (\d+)'): - (lambda self, ics: setattr(self, 'involuntary_cs', int(ics))), + re.compile( + r"\s+MAX_RSS \d+ - \d+ = (\d+) \((\d+) pages\)" + ): _store_memory_stats, + re.compile(r"\s+VCS \d+ - \d+ = (\d+)"): ( + lambda self, vcs: setattr(self, "voluntary_cs", int(vcs)) + ), + re.compile(r"\s+ICS \d+ - \d+ = (\d+)"): ( + lambda self, ics: setattr(self, "involuntary_cs", int(ics)) + ), } def parse_results(self, lines): @@ -511,10 +536,10 @@ def __init__(self, old_results, new_results, delta_threshold): added_tests = new_tests.difference(old_tests) removed_tests = old_tests.difference(new_tests) - self.added = sorted([new_results[t] for t in added_tests], - key=lambda r: r.name) - self.removed = sorted([old_results[t] for t in removed_tests], - key=lambda r: r.name) + self.added = sorted([new_results[t] for t in added_tests], key=lambda r: r.name) + self.removed = sorted( + [old_results[t] for t in removed_tests], key=lambda r: r.name + ) def compare(name): return ResultComparison(old_results[name], new_results[name]) @@ -525,19 +550,24 @@ def partition(l, p): return reduce(lambda x, y: x[not p(y)].append(y) or x, l, ([], [])) decreased, not_decreased = partition( - comparisons, lambda c: c.ratio < (1 - delta_threshold)) + comparisons, lambda c: c.ratio < (1 - delta_threshold) + ) increased, unchanged = partition( - not_decreased, lambda c: c.ratio > (1 + delta_threshold)) + not_decreased, lambda c: c.ratio > (1 + delta_threshold) + ) # sorted partitions names = [c.name for c in comparisons] comparisons = dict(zip(names, comparisons)) - self.decreased = [comparisons[c.name] - for c in sorted(decreased, key=lambda c: -c.delta)] - self.increased = [comparisons[c.name] - for c in sorted(increased, key=lambda c: c.delta)] - self.unchanged = [comparisons[c.name] - for c in sorted(unchanged, key=lambda c: c.name)] + self.decreased = [ + comparisons[c.name] for c in sorted(decreased, key=lambda c: -c.delta) + ] + self.increased = [ + comparisons[c.name] for c in sorted(increased, key=lambda c: c.delta) + ] + self.unchanged = [ + comparisons[c.name] for c in sorted(unchanged, key=lambda c: c.name) + ] class ReportFormatter(object): @@ -549,23 +579,25 @@ class ReportFormatter(object): GitHub), `git` and `html`. """ - def __init__(self, comparator, changes_only, - single_table=False): + def __init__(self, comparator, changes_only, single_table=False): """Initialize with `TestComparator` and names of branches.""" self.comparator = comparator self.changes_only = changes_only self.single_table = single_table - PERFORMANCE_TEST_RESULT_HEADER = ('TEST', 'MIN', 'MAX', 'MEAN', 'MAX_RSS') - RESULT_COMPARISON_HEADER = ('TEST', 'OLD', 'NEW', 'DELTA', 'RATIO') + PERFORMANCE_TEST_RESULT_HEADER = ("TEST", "MIN", "MAX", "MEAN", "MAX_RSS") + RESULT_COMPARISON_HEADER = ("TEST", "OLD", "NEW", "DELTA", "RATIO") @staticmethod def header_for(result): """Column labels for header row in results table.""" - return (ReportFormatter.PERFORMANCE_TEST_RESULT_HEADER - if isinstance(result, PerformanceTestResult) else - # isinstance(result, ResultComparison) - ReportFormatter.RESULT_COMPARISON_HEADER) + return ( + ReportFormatter.PERFORMANCE_TEST_RESULT_HEADER + if isinstance(result, PerformanceTestResult) + else + # isinstance(result, ResultComparison) + ReportFormatter.RESULT_COMPARISON_HEADER + ) @staticmethod def values(result): @@ -574,53 +606,63 @@ def values(result): Returns tuple of strings to display in the results table. """ return ( - (result.name, - str(result.min), str(result.max), str(int(result.mean)), - str(result.max_rss) if result.max_rss else '—') - if isinstance(result, PerformanceTestResult) else + ( + result.name, + str(result.min), + str(result.max), + str(int(result.mean)), + str(result.max_rss) if result.max_rss else "—", + ) + if isinstance(result, PerformanceTestResult) + else # isinstance(result, ResultComparison) - (result.name, - str(result.old.min), str(result.new.min), - '{0:+.1f}%'.format(result.delta), - '{0:.2f}x{1}'.format(result.ratio, - ' (?)' if result.is_dubious else '')) + ( + result.name, + str(result.old.min), + str(result.new.min), + "{0:+.1f}%".format(result.delta), + "{0:.2f}x{1}".format(result.ratio, " (?)" if result.is_dubious else ""), + ) ) def markdown(self): """Report results of benchmark comparisons in Markdown format.""" return self._formatted_text( - label_formatter=lambda s: ('**' + s + '**'), - COLUMN_SEPARATOR=' | ', - DELIMITER_ROW=([':---'] + ['---:'] * 4), - SEPARATOR='  | | | | \n', + label_formatter=lambda s: ("**" + s + "**"), + COLUMN_SEPARATOR=" | ", + DELIMITER_ROW=([":---"] + ["---:"] * 4), + SEPARATOR="  | | | | \n", SECTION="""
{0} ({1}) {2}
-""") +""", + ) def git(self): """Report results of benchmark comparisons in 'git' format.""" return self._formatted_text( label_formatter=lambda s: s.upper(), - COLUMN_SEPARATOR=' ', + COLUMN_SEPARATOR=" ", DELIMITER_ROW=None, - SEPARATOR='\n', + SEPARATOR="\n", SECTION=""" -{0} ({1}): \n{2}""") +{0} ({1}): \n{2}""", + ) def _column_widths(self): changed = self.comparator.decreased + self.comparator.increased - results = (changed if self.changes_only else - changed + self.comparator.unchanged) + results = changed if self.changes_only else changed + self.comparator.unchanged results += self.comparator.added + self.comparator.removed widths = [ - map(len, columns) for columns in - [ReportFormatter.PERFORMANCE_TEST_RESULT_HEADER, - ReportFormatter.RESULT_COMPARISON_HEADER] + - [ReportFormatter.values(r) for r in results] + map(len, columns) + for columns in [ + ReportFormatter.PERFORMANCE_TEST_RESULT_HEADER, + ReportFormatter.RESULT_COMPARISON_HEADER, + ] + + [ReportFormatter.values(r) for r in results] ] def max_widths(maximum, widths): @@ -628,8 +670,9 @@ def max_widths(maximum, widths): return reduce(max_widths, widths, [0] * 5) - def _formatted_text(self, label_formatter, COLUMN_SEPARATOR, - DELIMITER_ROW, SEPARATOR, SECTION): + def _formatted_text( + self, label_formatter, COLUMN_SEPARATOR, DELIMITER_ROW, SEPARATOR, SECTION + ): widths = self._column_widths() self.header_printed = False @@ -637,43 +680,62 @@ def justify_columns(contents): return [c.ljust(w) for w, c in zip(widths, contents)] def row(contents): - return ('' if not contents else - COLUMN_SEPARATOR.join(justify_columns(contents)) + '\n') + return ( + "" + if not contents + else COLUMN_SEPARATOR.join(justify_columns(contents)) + "\n" + ) def header(title, column_labels): - labels = (column_labels if not self.single_table else - map(label_formatter, (title, ) + column_labels[1:])) - h = (('' if not self.header_printed else SEPARATOR) + - row(labels) + - (row(DELIMITER_ROW) if not self.header_printed else '')) + labels = ( + column_labels + if not self.single_table + else map(label_formatter, (title,) + column_labels[1:]) + ) + h = ( + ("" if not self.header_printed else SEPARATOR) + + row(labels) + + (row(DELIMITER_ROW) if not self.header_printed else "") + ) if self.single_table and not self.header_printed: self.header_printed = True return h def format_columns(r, is_strong): - return (r if not is_strong else - r[:-1] + ('**' + r[-1] + '**', )) + return r if not is_strong else r[:-1] + ("**" + r[-1] + "**",) def table(title, results, is_strong=False, is_open=False): if not results: - return '' - rows = [row(format_columns(ReportFormatter.values(r), is_strong)) - for r in results] - table = (header(title if self.single_table else '', - ReportFormatter.header_for(results[0])) + - ''.join(rows)) - return (table if self.single_table else - SECTION.format( - title, len(results), table, 'open' if is_open else '')) - - return '\n' + ''.join([ - table('Regression', self.comparator.decreased, True, True), - table('Improvement', self.comparator.increased, True), - ('' if self.changes_only else - table('No Changes', self.comparator.unchanged)), - table('Added', self.comparator.added, is_open=True), - table('Removed', self.comparator.removed, is_open=True) - ]) + return "" + rows = [ + row(format_columns(ReportFormatter.values(r), is_strong)) + for r in results + ] + table = header( + title if self.single_table else "", + ReportFormatter.header_for(results[0]), + ) + "".join(rows) + return ( + table + if self.single_table + else SECTION.format( + title, len(results), table, "open" if is_open else "" + ) + ) + + return "\n" + "".join( + [ + table("Regression", self.comparator.decreased, True, True), + table("Improvement", self.comparator.increased, True), + ( + "" + if self.changes_only + else table("No Changes", self.comparator.unchanged) + ), + table("Added", self.comparator.added, is_open=True), + table("Removed", self.comparator.removed, is_open=True), + ] + ) HTML = """ @@ -722,68 +784,90 @@ def table(title, results, is_strong=False, is_open=False): def html(self): """Report results of benchmark comparisons in HTML format.""" + def row(name, old, new, delta, speedup, speedup_color): - return self.HTML_ROW.format( - name, old, new, delta, speedup_color, speedup) + return self.HTML_ROW.format(name, old, new, delta, speedup_color, speedup) def header(contents): - return self.HTML_HEADER_ROW.format(* contents) + return self.HTML_HEADER_ROW.format(*contents) def table(title, results, speedup_color): rows = [ - row(*(ReportFormatter.values(r) + (speedup_color,))) - for r in results + row(*(ReportFormatter.values(r) + (speedup_color,))) for r in results ] - return ('' if not rows else - header((title, len(results)) + - ReportFormatter.header_for(results[0])[1:]) + - ''.join(rows)) + return ( + "" + if not rows + else header( + (title, len(results)) + ReportFormatter.header_for(results[0])[1:] + ) + + "".join(rows) + ) return self.HTML.format( - ''.join([ - table('Regression', self.comparator.decreased, 'red'), - table('Improvement', self.comparator.increased, 'green'), - ('' if self.changes_only else - table('No Changes', self.comparator.unchanged, 'black')), - table('Added', self.comparator.added, ''), - table('Removed', self.comparator.removed, '') - ])) + "".join( + [ + table("Regression", self.comparator.decreased, "red"), + table("Improvement", self.comparator.increased, "green"), + ( + "" + if self.changes_only + else table("No Changes", self.comparator.unchanged, "black") + ), + table("Added", self.comparator.added, ""), + table("Removed", self.comparator.removed, ""), + ] + ) + ) def parse_args(args): """Parse command line arguments and set default values.""" - parser = argparse.ArgumentParser(description='Compare Performance tests.') - parser.add_argument('--old-file', - help='Baseline performance test suite (csv file)', - required=True) - parser.add_argument('--new-file', - help='New performance test suite (csv file)', - required=True) - parser.add_argument('--format', - choices=['markdown', 'git', 'html'], - help='Output format. Default is markdown.', - default="markdown") - parser.add_argument('--output', help='Output file name') - parser.add_argument('--changes-only', - help='Output only affected tests', action='store_true') + parser = argparse.ArgumentParser(description="Compare Performance tests.") + parser.add_argument( + "--old-file", help="Baseline performance test suite (csv file)", required=True + ) + parser.add_argument( + "--new-file", help="New performance test suite (csv file)", required=True + ) + parser.add_argument( + "--format", + choices=["markdown", "git", "html"], + help="Output format. Default is markdown.", + default="markdown", + ) + parser.add_argument("--output", help="Output file name") + parser.add_argument( + "--changes-only", help="Output only affected tests", action="store_true" + ) + parser.add_argument( + "--single-table", + help="Combine data in a single table in git and markdown formats", + action="store_true", + ) parser.add_argument( - '--single-table', - help='Combine data in a single table in git and markdown formats', - action='store_true') - parser.add_argument('--delta-threshold', - help='Delta threshold. Default 0.05.', - type=float, default=0.05) + "--delta-threshold", + help="Delta threshold. Default 0.05.", + type=float, + default=0.05, + ) return parser.parse_args(args) -def create_report(old_results, new_results, delta_threshold, format, - changes_only=True, single_table=True): +def create_report( + old_results, + new_results, + delta_threshold, + format, + changes_only=True, + single_table=True, +): comparator = TestComparator(old_results, new_results, delta_threshold) formatter = ReportFormatter(comparator, changes_only, single_table) formats = { - 'markdown': formatter.markdown, - 'git': formatter.git, - 'html': formatter.html + "markdown": formatter.markdown, + "git": formatter.git, + "html": formatter.html, } report = formats[format]() @@ -793,16 +877,20 @@ def create_report(old_results, new_results, delta_threshold, format, def main(): """Compare benchmarks for changes in a formatted report.""" args = parse_args(sys.argv[1:]) - report = create_report(LogParser.results_from_file(args.old_file), - LogParser.results_from_file(args.new_file), - args.delta_threshold, args.format, - args.changes_only, args.single_table) + report = create_report( + LogParser.results_from_file(args.old_file), + LogParser.results_from_file(args.new_file), + args.delta_threshold, + args.format, + args.changes_only, + args.single_table, + ) print(report) if args.output: - with open(args.output, 'w') as f: + with open(args.output, "w") as f: f.write(report) -if __name__ == '__main__': +if __name__ == "__main__": sys.exit(main()) diff --git a/benchmark/scripts/create_benchmark.py b/benchmark/scripts/create_benchmark.py index 2e2a4786752ae..cccaae23c76bd 100755 --- a/benchmark/scripts/create_benchmark.py +++ b/benchmark/scripts/create_benchmark.py @@ -7,7 +7,7 @@ def main(): p = argparse.ArgumentParser() - p.add_argument('name', help='The name of the new benchmark to be created') + p.add_argument("name", help="The name of the new benchmark to be created") args = p.parse_args() # adds benchmark to `CMakeLists.txt` @@ -24,19 +24,19 @@ def update_cmakelists(name): """Adds a new entry to the `CMakeLists.txt` file with the given benchmark name. """ - relative_path = create_relative_path('../CMakeLists.txt') + relative_path = create_relative_path("../CMakeLists.txt") file_contents = [] - with open(relative_path, 'r') as f: + with open(relative_path, "r") as f: file_contents = f.readlines() file_new_contents = insert_line_alphabetically( name, - ' single-source/' + name + '\n', + " single-source/" + name + "\n", file_contents, - r" single-source\/([a-zA-Z]+)" + r" single-source\/([a-zA-Z]+)", ) - with open(relative_path, 'w') as f: + with open(relative_path, "w") as f: for line in file_new_contents: f.write(line) @@ -46,17 +46,17 @@ def create_benchmark_file(name): and places it in the `single-source` directory. """ - template_path = create_relative_path('Template.swift') - benchmark_template = '' - with open(template_path, 'r') as f: - benchmark_template = ''.join(f.readlines()) + template_path = create_relative_path("Template.swift") + benchmark_template = "" + with open(template_path, "r") as f: + benchmark_template = "".join(f.readlines()) # fill in template with benchmark name. formatted_template = benchmark_template.format(name=name) - relative_path = create_relative_path('../single-source/') - source_file_path = os.path.join(relative_path, name + '.swift') - with open(source_file_path, 'w') as f: + relative_path = create_relative_path("../single-source/") + source_file_path = os.path.join(relative_path, name + ".swift") + with open(source_file_path, "w") as f: f.write(formatted_template) @@ -64,14 +64,14 @@ def add_import_benchmark(name): """Adds an `import` statement to the `main.swift` file for the new benchmark. """ - relative_path = create_relative_path('../utils/main.swift') + relative_path = create_relative_path("../utils/main.swift") # read current contents into an array file_contents = [] - with open(relative_path, 'r') as f: + with open(relative_path, "r") as f: file_contents = f.readlines() - # the test dependencies are placed before all benchmarks, so we have to + # the test dependencies are placed before all benchmarks, so we have to # insert the benchmark in the right alphabetical order after we have seen # all test dependencies. read_test_dependencies = False @@ -82,23 +82,27 @@ def add_import_benchmark(name): match = re.search(r"import ([a-zA-Z]+)", line) if match and match.group(1): benchmark_name = match.group(1) - # find where to insert the new benchmark in the right alphabetical + # find where to insert the new benchmark in the right alphabetical # order. - if (name < benchmark_name and previous_benchmark_name is None or - name < benchmark_name and name > previous_benchmark_name): + if ( + name < benchmark_name + and previous_benchmark_name is None + or name < benchmark_name + and name > previous_benchmark_name + ): if read_test_dependencies: - file_new_contents.append('import ' + name + '\n' + line) + file_new_contents.append("import " + name + "\n" + line) else: - # all test dependencies are first specified, so from now + # all test dependencies are first specified, so from now # on we can look where to insert the new benchmark. read_test_dependencies = True file_new_contents.append(line) else: - file_new_contents.append(line) + file_new_contents.append(line) previous_benchmark_name = benchmark_name else: file_new_contents.append(line) - with open(relative_path, 'w') as f: + with open(relative_path, "w") as f: for line in file_new_contents: f.write(line) @@ -107,19 +111,19 @@ def add_register_benchmark(name): """Adds an `import` statement to the `main.swift` file for the new benchmark. """ - relative_path = create_relative_path('../utils/main.swift') + relative_path = create_relative_path("../utils/main.swift") file_contents = [] - with open(relative_path, 'r') as f: + with open(relative_path, "r") as f: file_contents = f.readlines() file_new_contents = insert_line_alphabetically( name, - 'registerBenchmark(' + name + ')\n', - file_contents, - r"registerBenchmark\(([a-zA-Z]+)\)" + "registerBenchmark(" + name + ")\n", + file_contents, + r"registerBenchmark\(([a-zA-Z]+)\)", ) - with open(relative_path, 'w') as f: + with open(relative_path, "w") as f: for line in file_new_contents: f.write(line) @@ -129,7 +133,7 @@ def insert_line_alphabetically(name, new_line, lines, regex): find where the new benchmark should be inserted with the given `new_line`. """ # the name of the previous seen benchmark in order to insert the new - # one at the correct position + # one at the correct position previous_benchmark_name = None # the new contents of the file updated_lines = [] @@ -140,11 +144,15 @@ def insert_line_alphabetically(name, new_line, lines, regex): benchmark_name = match.group(1) # check if we're at the line where we have to insert the new # benchmark in the correct alphabetical order - if (name < benchmark_name and previous_benchmark_name is None or - name < benchmark_name and name > previous_benchmark_name): + if ( + name < benchmark_name + and previous_benchmark_name is None + or name < benchmark_name + and name > previous_benchmark_name + ): updated_lines.append(new_line + line) else: - updated_lines.append(line) + updated_lines.append(line) previous_benchmark_name = benchmark_name else: updated_lines.append(line) diff --git a/benchmark/scripts/generate_harness/generate_harness.py b/benchmark/scripts/generate_harness/generate_harness.py index 6e4bc0f815c5e..c5c6f87242133 100755 --- a/benchmark/scripts/generate_harness/generate_harness.py +++ b/benchmark/scripts/generate_harness/generate_harness.py @@ -21,12 +21,12 @@ import subprocess script_dir = os.path.dirname(os.path.realpath(__file__)) -perf_dir = os.path.realpath(os.path.join(script_dir, '../..')) -gyb = os.path.realpath(os.path.join(perf_dir, '../utils/gyb')) +perf_dir = os.path.realpath(os.path.join(script_dir, "../..")) +gyb = os.path.realpath(os.path.join(perf_dir, "../utils/gyb")) parser = argparse.ArgumentParser() -parser.add_argument("--output-dir", - help="Output directory (for validation test)", - default=perf_dir) +parser.add_argument( + "--output-dir", help="Output directory (for validation test)", default=perf_dir +) args = parser.parse_args() output_dir = args.output_dir @@ -35,7 +35,8 @@ def all_files(directory, extension): # matching: [directory]/**/*[extension] return [ os.path.join(root, f) for root, _, files in os.walk(directory) - for f in files if f.endswith(extension) + for f in files + if f.endswith(extension) ] @@ -46,13 +47,13 @@ def will_write(filename): # ensure path to file exists before writing os.makedirs(output_path) -if __name__ == '__main__': +if __name__ == "__main__": # Generate Your Boilerplate # Make sure longer paths are done first as CMakeLists.txt and main.swift # depend on the other gybs being generated first. - gyb_files = sorted(all_files(perf_dir, '.gyb'), key=len, reverse=True) + gyb_files = sorted(all_files(perf_dir, ".gyb"), key=len, reverse=True) for f in gyb_files: relative_path = os.path.relpath(f[:-4], perf_dir) out_file = os.path.join(output_dir, relative_path) will_write(out_file) - subprocess.call([gyb, '--line-directive', '', '-o', out_file, f]) + subprocess.call([gyb, "--line-directive", "", "-o", out_file, f]) diff --git a/benchmark/scripts/perf_test_driver/perf_test_driver.py b/benchmark/scripts/perf_test_driver/perf_test_driver.py index 449059b031d74..7f8929f771764 100644 --- a/benchmark/scripts/perf_test_driver/perf_test_driver.py +++ b/benchmark/scripts/perf_test_driver/perf_test_driver.py @@ -21,29 +21,27 @@ import subprocess -BENCHMARK_OUTPUT_RE = re.compile(r'\d+,([^,]+)') +BENCHMARK_OUTPUT_RE = re.compile(r"\d+,([^,]+)") class Result(object): - def __init__(self, name, status, output, xfail_list): self.name = name self.status = status self.output = output - self.is_xfailed = any( - (re.match(x, self.name) is not None for x in xfail_list)) + self.is_xfailed = any((re.match(x, self.name) is not None for x in xfail_list)) def is_failure(self): - return self.get_result() in ['FAIL', 'XPASS'] + return self.get_result() in ["FAIL", "XPASS"] def get_result(self): if self.is_xfailed: if self.status: - return 'XFAIL' - return 'XPASS' + return "XFAIL" + return "XPASS" if self.status: - return 'FAIL' - return 'PASS' + return "FAIL" + return "PASS" def get_name(self): return self.name @@ -53,7 +51,7 @@ def merge_in_extra_data(self, d): return d def print_data(self, max_test_len): - fmt = '{:<%d}{:}' % (max_test_len + 5) + fmt = "{:<%d}{:}" % (max_test_len + 5) print(fmt.format(self.get_name(), self.get_result())) @@ -65,36 +63,44 @@ def run_with_timeout(func, args): # we update to use python >= 3.3, use the timeout API on communicate # instead. import multiprocessing.dummy + fakeThreadPool = multiprocessing.dummy.Pool(1) try: result = fakeThreadPool.apply_async(func, args=args) return result.get(timeout_seconds) except multiprocessing.TimeoutError: fakeThreadPool.terminate() - raise RuntimeError("Child process aborted due to timeout. " - "Timeout: %s seconds" % timeout_seconds) + raise RuntimeError( + "Child process aborted due to timeout. " + "Timeout: %s seconds" % timeout_seconds + ) def _unwrap_self(args): return type(args[0]).process_input(*args) -BenchmarkDriver_OptLevels = ['Onone', 'O', 'Osize'] +BenchmarkDriver_OptLevels = ["Onone", "O", "Osize"] class BenchmarkDriver(object): - - def __init__(self, binary_dir, xfail_list, enable_parallel=False, - opt_levels=BenchmarkDriver_OptLevels): - self.targets = [(os.path.join(binary_dir, 'Benchmark_%s' % o), o) - for o in opt_levels] + def __init__( + self, + binary_dir, + xfail_list, + enable_parallel=False, + opt_levels=BenchmarkDriver_OptLevels, + ): + self.targets = [ + (os.path.join(binary_dir, "Benchmark_%s" % o), o) for o in opt_levels + ] self.xfail_list = xfail_list self.enable_parallel = enable_parallel self.data = None def print_data_header(self, max_test_len): - fmt = '{:<%d}{:}' % (max_test_len + 5) - print(fmt.format('Name', 'Result')) + fmt = "{:<%d}{:}" % (max_test_len + 5) + print(fmt.format("Name", "Result")) def prepare_input(self, name, opt_level): raise RuntimeError("Abstract method") @@ -115,7 +121,7 @@ def run_for_opt_level(self, binary, opt_level, test_filter): names = [n for n in names if regex.match(n)] def prepare_input_wrapper(name): - x = {'opt': opt_level, 'path': binary, 'test_name': name} + x = {"opt": opt_level, "path": binary, "test_name": name} x.update(self.prepare_input(name)) return x @@ -129,33 +135,31 @@ def prepare_input_wrapper(name): results = map(self.process_input, prepared_input) def reduce_results(acc, r): - acc['result'].append(r) - acc['has_failure'] = acc['has_failure'] or r.is_failure() - acc['max_test_len'] = max(acc['max_test_len'], len(r.get_name())) - acc['extra_data'] = r.merge_in_extra_data(acc['extra_data']) + acc["result"].append(r) + acc["has_failure"] = acc["has_failure"] or r.is_failure() + acc["max_test_len"] = max(acc["max_test_len"], len(r.get_name())) + acc["extra_data"] = r.merge_in_extra_data(acc["extra_data"]) return acc - return functools.reduce(reduce_results, results, { - 'result': [], - 'has_failure': False, - 'max_test_len': 0, - 'extra_data': {} - }) + return functools.reduce( + reduce_results, + results, + {"result": [], "has_failure": False, "max_test_len": 0, "extra_data": {}}, + ) def print_data(self, data, max_test_len): print("Results:") self.print_data_header(max_test_len) for d in data: - for r in d['result']: + for r in d["result"]: r.print_data(max_test_len) def run(self, test_filter=None): self.data = [ self.run_for_opt_level(binary, opt_level, test_filter) - for binary, opt_level in self.targets] - max_test_len = functools.reduce(max, - [d['max_test_len'] for d in self.data]) - has_failure = functools.reduce(max, - [d['has_failure'] for d in self.data]) + for binary, opt_level in self.targets + ] + max_test_len = functools.reduce(max, [d["max_test_len"] for d in self.data]) + has_failure = functools.reduce(max, [d["has_failure"] for d in self.data]) self.print_data(self.data, max_test_len) return not has_failure diff --git a/benchmark/scripts/run_smoke_bench b/benchmark/scripts/run_smoke_bench index f478c7e95a869..0facbe7b344f5 100755 --- a/benchmark/scripts/run_smoke_bench +++ b/benchmark/scripts/run_smoke_bench @@ -28,14 +28,15 @@ import glob import os import subprocess import sys +from imp import load_source from compare_perf_tests import LogParser, TestComparator, create_report -from imp import load_source # import Benchmark_Driver # doesn't work because it misses '.py' extension Benchmark_Driver = load_source( - 'Benchmark_Driver', os.path.join(os.path.dirname( - os.path.abspath(__file__)), 'Benchmark_Driver')) + "Benchmark_Driver", + os.path.join(os.path.dirname(os.path.abspath(__file__)), "Benchmark_Driver"), +) # from Benchmark_Driver import BenchmarkDriver, BenchmarkDoctor, ... BenchmarkDriver = Benchmark_Driver.BenchmarkDriver BenchmarkDoctor = Benchmark_Driver.BenchmarkDoctor @@ -46,11 +47,12 @@ VERBOSE = False class DriverArgs(object): """Arguments for BenchmarkDriver.""" - def __init__(self, tests, optimization='O'): + + def __init__(self, tests, optimization="O"): """Initialize with path to the build-dir and optimization level.""" self.benchmarks = None self.filters = None - self.tests = os.path.join(tests, 'bin') + self.tests = os.path.join(tests, "bin") self.optimization = optimization @@ -63,49 +65,76 @@ def main(): global VERBOSE argparser = argparse.ArgumentParser() argparser.add_argument( - '-verbose', action='store_true', - help='print verbose messages') + "-verbose", action="store_true", help="print verbose messages" + ) argparser.add_argument( - '-O', action='append_const', const='O', dest='opt_levels', - help='test -O benchmarks') + "-O", + action="append_const", + const="O", + dest="opt_levels", + help="test -O benchmarks", + ) argparser.add_argument( - '-Osize', action='append_const', const='Osize', dest='opt_levels', - help='test -Osize benchmarks') + "-Osize", + action="append_const", + const="Osize", + dest="opt_levels", + help="test -Osize benchmarks", + ) argparser.add_argument( - '-Onone', action='append_const', const='Onone', dest='opt_levels', - help='test -Onone benchmarks (except code size)') + "-Onone", + action="append_const", + const="Onone", + dest="opt_levels", + help="test -Onone benchmarks (except code size)", + ) argparser.add_argument( - '-skip-code-size', action='store_true', - help="Don't report code size differences") + "-skip-code-size", + action="store_true", + help="Don't report code size differences", + ) argparser.add_argument( - '-skip-performance', action='store_true', - help="Don't report performance differences") + "-skip-performance", + action="store_true", + help="Don't report performance differences", + ) argparser.add_argument( - '-skip-check-added', action='store_true', - help="Don't validate newly added benchmarks") + "-skip-check-added", + action="store_true", + help="Don't validate newly added benchmarks", + ) argparser.add_argument( - '-o', type=str, - help='In addition to stdout, write the results into a markdown file') + "-o", + type=str, + help="In addition to stdout, write the results into a markdown file", + ) argparser.add_argument( - '-threshold', type=float, - help='The performance threshold in %% which triggers a re-run', - default=5) + "-threshold", + type=float, + help="The performance threshold in %% which triggers a re-run", + default=5, + ) argparser.add_argument( - '-num-samples', type=int, - help='The (minimum) number of samples to run', default=3) + "-num-samples", + type=int, + help="The (minimum) number of samples to run", + default=3, + ) argparser.add_argument( - '-num-reruns', type=int, + "-num-reruns", + type=int, help="The number of re-runs until it's assumed to be a real change", - default=8) + default=8, + ) argparser.add_argument( - '-platform', type=str, - help='The benchmark build platform', default='macosx') + "-platform", type=str, help="The benchmark build platform", default="macosx" + ) argparser.add_argument( - 'oldbuilddir', nargs=1, type=str, - help='old benchmark build directory') + "oldbuilddir", nargs=1, type=str, help="old benchmark build directory" + ) argparser.add_argument( - 'newbuilddir', nargs=1, type=str, - help='new benchmark build directory') + "newbuilddir", nargs=1, type=str, help="new benchmark build directory" + ) args = argparser.parse_args() VERBOSE = args.verbose @@ -115,29 +144,42 @@ def main(): def test_opt_levels(args): output_file = None if args.o: - output_file = open(args.o, 'w') + output_file = open(args.o, "w") changes = False - for opt_level in args.opt_levels or ['O', 'Osize', 'Onone']: - log('####### Testing optimization level -' + opt_level + ' #######') + for opt_level in args.opt_levels or ["O", "Osize", "Onone"]: + log("####### Testing optimization level -" + opt_level + " #######") if not args.skip_performance: - if test_performance(opt_level, args.oldbuilddir[0], - args.newbuilddir[0], - float(args.threshold) / 100, args.num_samples, - args.num_reruns, output_file): + if test_performance( + opt_level, + args.oldbuilddir[0], + args.newbuilddir[0], + float(args.threshold) / 100, + args.num_samples, + args.num_reruns, + output_file, + ): changes = True # There is no point in reporting code size for Onone. - if not args.skip_code_size and opt_level != 'Onone': - if report_code_size(opt_level, args.oldbuilddir[0], - args.newbuilddir[0], - args.platform, output_file): + if not args.skip_code_size and opt_level != "Onone": + if report_code_size( + opt_level, + args.oldbuilddir[0], + args.newbuilddir[0], + args.platform, + output_file, + ): changes = True if not args.skip_code_size: - if report_code_size('swiftlibs', args.oldbuilddir[0], - args.newbuilddir[0], - args.platform, output_file): + if report_code_size( + "swiftlibs", + args.oldbuilddir[0], + args.newbuilddir[0], + args.platform, + output_file, + ): changes = True if not args.skip_check_added: @@ -158,10 +200,14 @@ def measure(driver, tests, i): Collect increasing number of samples, depending on the iteration. """ num_samples = min(i + 3, 10) - msg = ' Iteration {0} for {1}: num samples = {2}, '.format( - i, driver.args.tests, num_samples) - msg += ('running all tests' if driver.all_tests == tests else - 're-testing {0} tests'.format(len(tests))) + msg = " Iteration {0} for {1}: num samples = {2}, ".format( + i, driver.args.tests, num_samples + ) + msg += ( + "running all tests" + if driver.all_tests == tests + else "re-testing {0} tests".format(len(tests)) + ) log(msg) driver.tests = tests return driver.run(num_samples=num_samples, sample_time=0.0025) @@ -174,8 +220,9 @@ def merge(results, other_results): return results -def test_performance(opt_level, old_dir, new_dir, threshold, num_samples, - num_reruns, output_file): +def test_performance( + opt_level, old_dir, new_dir, threshold, num_samples, num_reruns, output_file +): """Detect performance changes in benchmarks. Start fast with few samples per benchmark and gradually spend more time @@ -183,8 +230,10 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples, """ i, unchanged_length_count = 0, 0 - old, new = [BenchmarkDriver(DriverArgs(dir, optimization=opt_level)) - for dir in [old_dir, new_dir]] + old, new = [ + BenchmarkDriver(DriverArgs(dir, optimization=opt_level)) + for dir in [old_dir, new_dir] + ] results = [measure(driver, driver.tests, i) for driver in [old, new]] tests = TestComparator(results[0], results[1], threshold) changed = tests.decreased + tests.increased @@ -192,10 +241,11 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples, while len(changed) > 0 and unchanged_length_count < num_reruns: i += 1 if VERBOSE: - log(' test again: ' + str([test.name for test in changed])) - results = [merge(the_results, - measure(driver, [test.name for test in changed], i)) - for the_results, driver in zip(results, [old, new])] + log(" test again: " + str([test.name for test in changed])) + results = [ + merge(the_results, measure(driver, [test.name for test in changed], i)) + for the_results, driver in zip(results, [old, new]) + ] tests = TestComparator(results[0], results[1], threshold) changed = tests.decreased + tests.increased @@ -204,19 +254,19 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples, else: unchanged_length_count = 0 - log('') - return report_results("Performance: -" + opt_level, None, None, - threshold * 1.4, output_file, *results) + log("") + return report_results( + "Performance: -" + opt_level, None, None, threshold * 1.4, output_file, *results + ) def report_code_size(opt_level, old_dir, new_dir, platform, output_file): - if opt_level == 'swiftlibs': - files = glob.glob(os.path.join(old_dir, 'lib', 'swift', platform, - '*.dylib')) + if opt_level == "swiftlibs": + files = glob.glob(os.path.join(old_dir, "lib", "swift", platform, "*.dylib")) else: - files = glob.glob(os.path.join(old_dir, - opt_level + '-*' + platform + '*', - '*.o')) + files = glob.glob( + os.path.join(old_dir, opt_level + "-*" + platform + "*", "*.o") + ) idx = 1 old_lines = "" @@ -229,37 +279,44 @@ def report_code_size(opt_level, old_dir, new_dir, platform, output_file): bname = os.path.basename(oldfile) def result_line(value): - v = ',' + str(value) - return (str(idx) + ',' + bname + ',1' + (v * 3) + - ',0' + v + '\n') + v = "," + str(value) + return str(idx) + "," + bname + ",1" + (v * 3) + ",0" + v + "\n" old_lines += result_line(oldsize) new_lines += result_line(newsize) idx += 1 - return report_results("Code size: -" + opt_level, - old_lines, new_lines, 0.01, output_file) + return report_results( + "Code size: -" + opt_level, old_lines, new_lines, 0.01, output_file + ) def get_codesize(filename): - output = subprocess.check_output(['size', filename]).splitlines() + output = subprocess.check_output(["size", filename]).splitlines() header_line = output[0] data_line = output[1] - if header_line.find('__TEXT') != 0: - sys.exit('unexpected output from size command:\n' + output) - return int(data_line.split('\t')[0]) - - -def report_results(title, old_lines, new_lines, threshold, output_file, - old_results=None, new_results=None): + if header_line.find("__TEXT") != 0: + sys.exit("unexpected output from size command:\n" + output) + return int(data_line.split("\t")[0]) + + +def report_results( + title, + old_lines, + new_lines, + threshold, + output_file, + old_results=None, + new_results=None, +): old_results = old_results or LogParser.results_from_string(old_lines) new_results = new_results or LogParser.results_from_string(new_lines) print("------- " + title + " -------") - print(create_report(old_results, new_results, threshold, 'git')) + print(create_report(old_results, new_results, threshold, "git")) if output_file: - report = create_report(old_results, new_results, threshold, 'markdown') + report = create_report(old_results, new_results, threshold, "markdown") if report != "": output_file.write("### " + title + "\n") output_file.write(report) @@ -289,17 +346,19 @@ performance team (@eeckstein). Hardware Overview """ - po = subprocess.check_output(['system_profiler', 'SPHardwareDataType']) + po = subprocess.check_output(["system_profiler", "SPHardwareDataType"]) for line in po.splitlines(): - selection = ['Model Name', - 'Model Identifier', - 'Processor Name', - 'Processor Speed', - 'Number of Processors', - 'Total Number of Cores', - 'L2 Cache', - 'L3 Cache', - 'Memory:'] + selection = [ + "Model Name", + "Model Identifier", + "Processor Name", + "Processor Speed", + "Number of Processors", + "Total Number of Cores", + "L2 Cache", + "L3 Cache", + "Memory:", + ] if any(s in line for s in selection): text += line + "\n" @@ -320,5 +379,5 @@ def check_added(args, output_file=None): doctor.check() -if __name__ == '__main__': +if __name__ == "__main__": sys.exit(main()) diff --git a/benchmark/scripts/test_Benchmark_Driver.py b/benchmark/scripts/test_Benchmark_Driver.py index 32b1a9e527635..570fee82f2f8b 100644 --- a/benchmark/scripts/test_Benchmark_Driver.py +++ b/benchmark/scripts/test_Benchmark_Driver.py @@ -26,8 +26,9 @@ # import Benchmark_Driver # doesn't work because it misses '.py' extension Benchmark_Driver = load_source( - 'Benchmark_Driver', os.path.join(os.path.dirname( - os.path.abspath(__file__)), 'Benchmark_Driver')) + "Benchmark_Driver", + os.path.join(os.path.dirname(os.path.abspath(__file__)), "Benchmark_Driver"), +) # from Benchmark_Driver import parse_args parse_args = Benchmark_Driver.parse_args BenchmarkDriver = Benchmark_Driver.BenchmarkDriver @@ -45,121 +46,122 @@ def assert_contains(self, texts, output): def test_requires_command_argument(self): with captured_output() as (_, err): self.assertRaises(SystemExit, parse_args, []) - self.assert_contains(['usage:', 'COMMAND', 'too few arguments'], - err.getvalue()) + self.assert_contains(["usage:", "COMMAND", "too few arguments"], err.getvalue()) def test_command_help_lists_commands(self): with captured_output() as (out, _): - self.assertRaises(SystemExit, parse_args, ['-h']) - self.assert_contains(['COMMAND', 'run', 'compare', 'check'], - out.getvalue()) + self.assertRaises(SystemExit, parse_args, ["-h"]) + self.assert_contains(["COMMAND", "run", "compare", "check"], out.getvalue()) def test_run_benchmarks_by_name_or_ordinal(self): - benchmarks = ['AngryPhonebook', '42'] - self.assertEqual( - parse_args(['run'] + benchmarks).benchmarks, benchmarks) + benchmarks = ["AngryPhonebook", "42"] + self.assertEqual(parse_args(["run"] + benchmarks).benchmarks, benchmarks) def test_run_benchmarks_matching_pattern(self): - regexes = ['Prefix', '.*Suffix.*'] - filters = ['-f', regexes[0], '-f', regexes[1]] - self.assertEqual(parse_args(['run'] + filters).filters, regexes) + regexes = ["Prefix", ".*Suffix.*"] + filters = ["-f", regexes[0], "-f", regexes[1]] + self.assertEqual(parse_args(["run"] + filters).filters, regexes) def test_run_benchmarks_and_filters_are_exclusive(self): with captured_output() as (_, err): - self.assertRaises(SystemExit, - parse_args, 'run -f Filter1 Benchmark1'.split()) + self.assertRaises( + SystemExit, parse_args, "run -f Filter1 Benchmark1".split() + ) self.assert_contains( - ['error', - 'argument BENCHMARK: not allowed with argument -f/--filter'], - err.getvalue()) + ["error", "argument BENCHMARK: not allowed with argument -f/--filter"], + err.getvalue(), + ) def test_tests_location(self): here = os.path.dirname(os.path.abspath(__file__)) - self.assertEqual(parse_args(['run']).tests, here) - tests = '/benchmarks/are/here' - self.assertEqual(parse_args(['run', '-t', tests]).tests, tests) + self.assertEqual(parse_args(["run"]).tests, here) + tests = "/benchmarks/are/here" + self.assertEqual(parse_args(["run", "-t", tests]).tests, tests) def test_optimization_argument(self): - self.assertEqual(parse_args(['run']).optimization, 'O') - self.assertEqual( - parse_args(['run', '-o', 'O']).optimization, 'O') - self.assertEqual( - parse_args(['run', '-o', 'Onone']).optimization, 'Onone') - self.assertEqual( - parse_args(['run', '-o', 'Osize']).optimization, 'Osize') + self.assertEqual(parse_args(["run"]).optimization, "O") + self.assertEqual(parse_args(["run", "-o", "O"]).optimization, "O") + self.assertEqual(parse_args(["run", "-o", "Onone"]).optimization, "Onone") + self.assertEqual(parse_args(["run", "-o", "Osize"]).optimization, "Osize") with captured_output() as (_, err): - self.assertRaises(SystemExit, - parse_args, ['run', '-o', 'bogus']) + self.assertRaises(SystemExit, parse_args, ["run", "-o", "bogus"]) self.assert_contains( - ['error:', - "argument -o/--optimization: invalid choice: 'bogus'", - "(choose from 'O', 'Onone', 'Osize')"], - err.getvalue()) + [ + "error:", + "argument -o/--optimization: invalid choice: 'bogus'", + "(choose from 'O', 'Onone', 'Osize')", + ], + err.getvalue(), + ) def test_independent_samples(self): - self.assertEqual(parse_args(['run']).independent_samples, 1) - self.assertEqual(parse_args(['run', '-i', '3']).independent_samples, - 3) + self.assertEqual(parse_args(["run"]).independent_samples, 1) + self.assertEqual(parse_args(["run", "-i", "3"]).independent_samples, 3) with captured_output() as (out, err): - self.assertRaises(SystemExit, - parse_args, ['run', '-i', '-3']) + self.assertRaises(SystemExit, parse_args, ["run", "-i", "-3"]) self.assert_contains( - ['error:', "argument -i/--independent-samples: " + - "invalid positive_int value: '-3'"], - err.getvalue()) + [ + "error:", + "argument -i/--independent-samples: " + + "invalid positive_int value: '-3'", + ], + err.getvalue(), + ) def test_output_dir(self): - self.assertIsNone(parse_args(['run']).output_dir) - self.assertEqual( - parse_args(['run', '--output-dir', '/log']).output_dir, '/log') + self.assertIsNone(parse_args(["run"]).output_dir) + self.assertEqual(parse_args(["run", "--output-dir", "/log"]).output_dir, "/log") def test_check_supports_vebose_output(self): - self.assertFalse(parse_args(['check']).verbose) - self.assertTrue(parse_args(['check', '-v']).verbose) - self.assertTrue(parse_args(['check', '--verbose']).verbose) + self.assertFalse(parse_args(["check"]).verbose) + self.assertTrue(parse_args(["check", "-v"]).verbose) + self.assertTrue(parse_args(["check", "--verbose"]).verbose) def test_check_supports_mardown_output(self): - self.assertFalse(parse_args(['check']).markdown) - self.assertTrue(parse_args(['check', '-md']).markdown) - self.assertTrue(parse_args(['check', '--markdown']).markdown) + self.assertFalse(parse_args(["check"]).markdown) + self.assertTrue(parse_args(["check", "-md"]).markdown) + self.assertTrue(parse_args(["check", "--markdown"]).markdown) def test_check_flags_are_mutually_exclusive(self): with captured_output() as (out, err): - self.assertRaises(SystemExit, - parse_args, ['check', '-md', '-v']) + self.assertRaises(SystemExit, parse_args, ["check", "-md", "-v"]) self.assert_contains( - ['error:', 'argument -v/--verbose: ' + - 'not allowed with argument -md/--markdown'], - err.getvalue()) + [ + "error:", + "argument -v/--verbose: " + "not allowed with argument -md/--markdown", + ], + err.getvalue(), + ) class ArgsStub(object): def __init__(self): self.benchmarks = None self.filters = None - self.tests = '/benchmarks/' - self.optimization = 'O' + self.tests = "/benchmarks/" + self.optimization = "O" class SubprocessMock(Mock): """Mock for subprocess module's `check_output` method.""" + STDOUT = object() def __init__(self, responses=None): super(SubprocessMock, self).__init__(responses) - def _check_output(args, stdin=None, stdout=None, stderr=None, - shell=False): + def _check_output(args, stdin=None, stdout=None, stderr=None, shell=False): return self.record_and_respond(args, stdin, stdout, stderr, shell) + self.check_output = _check_output def record_and_respond(self, args, stdin, stdout, stderr, shell): # _ = stdin, stdout, shell # ignored in mock - assert stderr == self.STDOUT, 'Errors are NOT redirected to STDOUT' + assert stderr == self.STDOUT, "Errors are NOT redirected to STDOUT" args = tuple(args) self.calls.append(args) - return self.respond.get(args, '') + return self.respond.get(args, "") class TestBenchmarkDriverInitialization(unittest.TestCase): @@ -169,81 +171,95 @@ def setUp(self): def test_test_harness(self): self.assertEqual( - BenchmarkDriver(self.args, tests=['ignored']).test_harness, - '/benchmarks/Benchmark_O') - self.args.tests = '/path' - self.args.optimization = 'Suffix' + BenchmarkDriver(self.args, tests=["ignored"]).test_harness, + "/benchmarks/Benchmark_O", + ) + self.args.tests = "/path" + self.args.optimization = "Suffix" self.assertEqual( - BenchmarkDriver(self.args, tests=['ignored']).test_harness, - '/path/Benchmark_Suffix') + BenchmarkDriver(self.args, tests=["ignored"]).test_harness, + "/path/Benchmark_Suffix", + ) def test_gets_list_of_precommit_benchmarks(self): self.subprocess_mock.expect( - '/benchmarks/Benchmark_O --list --delim=\t'.split(' '), - '#\tTest\t[Tags]\n1\tBenchmark1\t[t1, t2]\n2\tBenchmark2\t[t3]\n') - driver = BenchmarkDriver( - self.args, _subprocess=self.subprocess_mock) + "/benchmarks/Benchmark_O --list --delim=\t".split(" "), + "#\tTest\t[Tags]\n1\tBenchmark1\t[t1, t2]\n2\tBenchmark2\t[t3]\n", + ) + driver = BenchmarkDriver(self.args, _subprocess=self.subprocess_mock) self.subprocess_mock.assert_called_all_expected() - self.assertEqual(driver.tests, - ['Benchmark1', 'Benchmark2']) - self.assertEqual(driver.all_tests, - ['Benchmark1', 'Benchmark2']) - self.assertEquals(driver.test_number['Benchmark1'], "1") - self.assertEquals(driver.test_number['Benchmark2'], "2") + self.assertEqual(driver.tests, ["Benchmark1", "Benchmark2"]) + self.assertEqual(driver.all_tests, ["Benchmark1", "Benchmark2"]) + self.assertEquals(driver.test_number["Benchmark1"], "1") + self.assertEquals(driver.test_number["Benchmark2"], "2") list_all_tests = ( - '/benchmarks/Benchmark_O --list --delim=\t --skip-tags='.split(' '), + "/benchmarks/Benchmark_O --list --delim=\t --skip-tags=".split(" "), """# Test [Tags] 1 Benchmark1 [t1, t2] 2 Benchmark2 [t3] 3 Benchmark3 [t3, t4] -""") +""", + ) def test_gets_list_of_all_benchmarks_when_benchmarks_args_exist(self): """Filters tests by name or test number, ignoring unknown.""" - self.args.benchmarks = '1 Benchmark3 1 bogus'.split() + self.args.benchmarks = "1 Benchmark3 1 bogus".split() self.subprocess_mock.expect(*self.list_all_tests) - driver = BenchmarkDriver( - self.args, _subprocess=self.subprocess_mock) + driver = BenchmarkDriver(self.args, _subprocess=self.subprocess_mock) self.subprocess_mock.assert_called_all_expected() - self.assertEqual(driver.tests, ['Benchmark1', 'Benchmark3']) - self.assertEqual(driver.all_tests, - ['Benchmark1', 'Benchmark2', 'Benchmark3']) + self.assertEqual(driver.tests, ["Benchmark1", "Benchmark3"]) + self.assertEqual(driver.all_tests, ["Benchmark1", "Benchmark2", "Benchmark3"]) def test_filters_benchmarks_by_pattern(self): - self.args.filters = '-f .+3'.split() + self.args.filters = "-f .+3".split() self.subprocess_mock.expect(*self.list_all_tests) - driver = BenchmarkDriver( - self.args, _subprocess=self.subprocess_mock) + driver = BenchmarkDriver(self.args, _subprocess=self.subprocess_mock) self.subprocess_mock.assert_called_all_expected() - self.assertEqual(driver.tests, ['Benchmark3']) - self.assertEqual(driver.all_tests, - ['Benchmark1', 'Benchmark2', 'Benchmark3']) + self.assertEqual(driver.tests, ["Benchmark3"]) + self.assertEqual(driver.all_tests, ["Benchmark1", "Benchmark2", "Benchmark3"]) def test_log_file(self): """When swift-repo is set, log is tied to Git branch and revision.""" - self.assertIsNone(BenchmarkDriver( - Stub(output_dir=None, tests='/bin/'), tests=['ignored']).log_file) + self.assertIsNone( + BenchmarkDriver( + Stub(output_dir=None, tests="/bin/"), tests=["ignored"] + ).log_file + ) - now = time.strftime('%Y%m%d%H%M%S', time.localtime()) + now = time.strftime("%Y%m%d%H%M%S", time.localtime()) driver = BenchmarkDriver( - Stub(output_dir='/path', tests='/bin/', optimization='Suffix', - swift_repo=None,), tests=['ignored']) - self.assertEqual(driver.log_file, - '/path/Benchmark_Suffix-' + now + '.log') - - r = '/repo/' - subprocess_mock = SubprocessMock(responses=[ - ('git -C {0} rev-parse --abbrev-ref HEAD'.format(r).split(' '), - 'branch\n'), - ('git -C {0} rev-parse --short HEAD'.format(r).split(' '), - 'short_hash\n'), - ]) + Stub( + output_dir="/path", + tests="/bin/", + optimization="Suffix", + swift_repo=None, + ), + tests=["ignored"], + ) + self.assertEqual(driver.log_file, "/path/Benchmark_Suffix-" + now + ".log") + + r = "/repo/" + subprocess_mock = SubprocessMock( + responses=[ + ( + "git -C {0} rev-parse --abbrev-ref HEAD".format(r).split(" "), + "branch\n", + ), + ( + "git -C {0} rev-parse --short HEAD".format(r).split(" "), + "short_hash\n", + ), + ] + ) driver = BenchmarkDriver( - Stub(output_dir='/log/', tests='', optimization='S', swift_repo=r), - tests=['ignored'], _subprocess=subprocess_mock) - self.assertEqual(driver.log_file, - '/log/branch/Benchmark_S-' + now + '-short_hash.log') + Stub(output_dir="/log/", tests="", optimization="S", swift_repo=r), + tests=["ignored"], + _subprocess=subprocess_mock, + ) + self.assertEqual( + driver.log_file, "/log/branch/Benchmark_S-" + now + "-short_hash.log" + ) subprocess_mock.assert_called_all_expected() @@ -253,8 +269,8 @@ class LogParserStub(object): @staticmethod def results_from_string(log_contents): LogParserStub.results_from_string_called = True - r = PerformanceTestResult('3,b1,1,123,123,123,0,123'.split(',')) - return {'b1': r} + r = PerformanceTestResult("3,b1,1,123,123,123,0,123".split(",")) + return {"b1": r} class TestBenchmarkDriverRunningTests(unittest.TestCase): @@ -263,34 +279,38 @@ def setUp(self): self.parser_stub = LogParserStub() self.subprocess_mock = SubprocessMock() self.subprocess_mock.expect( - '/benchmarks/Benchmark_O --list --delim=\t'.split(' '), - '#\tTest\t[Tags]\n1\tb1\t[tag]\n') + "/benchmarks/Benchmark_O --list --delim=\t".split(" "), + "#\tTest\t[Tags]\n1\tb1\t[tag]\n", + ) self.driver = BenchmarkDriver( - self.args, _subprocess=self.subprocess_mock, - parser=self.parser_stub) + self.args, _subprocess=self.subprocess_mock, parser=self.parser_stub + ) def test_run_benchmark_with_multiple_samples(self): - self.driver.run('b1') - self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b1')) - self.driver.run('b2', num_samples=5) + self.driver.run("b1") + self.subprocess_mock.assert_called_with(("/benchmarks/Benchmark_O", "b1")) + self.driver.run("b2", num_samples=5) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b2', '--num-samples=5')) + ("/benchmarks/Benchmark_O", "b2", "--num-samples=5") + ) def test_run_benchmark_with_specified_number_of_iterations(self): - self.driver.run('b', num_iters=1) + self.driver.run("b", num_iters=1) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b', '--num-iters=1')) + ("/benchmarks/Benchmark_O", "b", "--num-iters=1") + ) def test_run_benchmark_for_specified_time(self): - self.driver.run('b', sample_time=0.5) + self.driver.run("b", sample_time=0.5) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b', '--sample-time=0.5')) + ("/benchmarks/Benchmark_O", "b", "--sample-time=0.5") + ) def test_run_benchmark_in_verbose_mode(self): - self.driver.run('b', verbose=True) + self.driver.run("b", verbose=True) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b', '--verbose')) + ("/benchmarks/Benchmark_O", "b", "--verbose") + ) def test_run_batch(self): """Run all active tests in a single execution of the Benchmark_X. @@ -298,10 +318,9 @@ def test_run_batch(self): Known test names are passed to the harness in a compressed form as test numbers. """ - self.driver.tests = ['b1', 'bx'] + self.driver.tests = ["b1", "bx"] self.driver.run() - self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', '1', 'bx')) + self.subprocess_mock.assert_called_with(("/benchmarks/Benchmark_O", "1", "bx")) def test_parse_results_from_running_benchmarks(self): """Parse measurements results using LogParser. @@ -309,55 +328,70 @@ def test_parse_results_from_running_benchmarks(self): Individual test run returns the first PerformanceTestResult directly. Batch run returns the dictionary of PerformanceTestResults. """ - r = self.driver.run('b') + r = self.driver.run("b") self.assertTrue(self.parser_stub.results_from_string_called) - self.assertEquals(r.name, 'b1') # non-matching name, just 1st result + self.assertEquals(r.name, "b1") # non-matching name, just 1st result r = self.driver.run() self.assertTrue(isinstance(r, dict)) - self.assertEquals(r['b1'].name, 'b1') + self.assertEquals(r["b1"].name, "b1") def test_measure_memory(self): - self.driver.run('b', measure_memory=True) + self.driver.run("b", measure_memory=True) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b', '--memory')) + ("/benchmarks/Benchmark_O", "b", "--memory") + ) def test_report_quantiles(self): """Use delta compression for quantile reports.""" - self.driver.run('b', quantile=4) + self.driver.run("b", quantile=4) self.subprocess_mock.assert_called_with( - ('/benchmarks/Benchmark_O', 'b', '--quantile=4', '--delta')) + ("/benchmarks/Benchmark_O", "b", "--quantile=4", "--delta") + ) def test_run_benchmark_independent_samples(self): """Extract up to 20 measurements from an independent run.""" self.driver.args.independent_samples = 3 - r = self.driver.run_independent_samples('b1') - self.assertEqual(self.subprocess_mock.calls.count( - ('/benchmarks/Benchmark_O', 'b1', '--num-iters=1', '--memory', - '--quantile=20', '--delta')), 3) + r = self.driver.run_independent_samples("b1") + self.assertEqual( + self.subprocess_mock.calls.count( + ( + "/benchmarks/Benchmark_O", + "b1", + "--num-iters=1", + "--memory", + "--quantile=20", + "--delta", + ) + ), + 3, + ) self.assertEqual(r.num_samples, 3) # results are merged def test_run_and_log(self): def mock_run(test): - self.assertEqual(test, 'b1') + self.assertEqual(test, "b1") return PerformanceTestResult( - '3,b1,5,101,1,1,1,1,888'.split(','), - quantiles=True, delta=True, memory=True) - driver = BenchmarkDriver(tests=['b1'], args=Stub(output_dir=None)) + "3,b1,5,101,1,1,1,1,888".split(","), + quantiles=True, + delta=True, + memory=True, + ) + + driver = BenchmarkDriver(tests=["b1"], args=Stub(output_dir=None)) driver.run_independent_samples = mock_run # patching with captured_output() as (out, _): log = driver.run_and_log() - header = '#,TEST,SAMPLES,MIN(μs),Q1(μs),MEDIAN(μs),Q3(μs),MAX(μs),' +\ - 'MAX_RSS(B)\n' - csv_log = '3,b1,5,101,102,103,104,105,888\n' + header = ( + "#,TEST,SAMPLES,MIN(μs),Q1(μs),MEDIAN(μs),Q3(μs),MAX(μs)," + "MAX_RSS(B)\n" + ) + csv_log = "3,b1,5,101,102,103,104,105,888\n" self.assertEqual(log, None) self.assertEqual( out.getvalue(), - header + - csv_log + - '\n' + - 'Total performance tests executed: 1\n') + header + csv_log + "\n" + "Total performance tests executed: 1\n", + ) with captured_output() as (out, _): log = driver.run_and_log(csv_console=False) @@ -365,66 +399,72 @@ def mock_run(test): self.assertEqual(log, header + csv_log) self.assertEqual( out.getvalue(), - ' # TEST SAMPLES MIN(μs)' + - ' Q1(μs) MEDIAN(μs) Q3(μs) MAX(μs) MAX_RSS(B)\n' + - ' 3 b1 5 101' + - ' 102 103 104 105 888\n' + - '\n' + - 'Total performance tests executed: 1\n') + " # TEST SAMPLES MIN(μs)" + + " Q1(μs) MEDIAN(μs) Q3(μs) MAX(μs) MAX_RSS(B)\n" + + " 3 b1 5 101" + + " 102 103 104 105 888\n" + + "\n" + + "Total performance tests executed: 1\n", + ) def test_log_results(self): """Create log directory if it doesn't exist and write the log file.""" + def assert_log_written(out, log_file, content): - self.assertEqual(out.getvalue(), - 'Logging results to: ' + log_file + '\n') - with open(log_file, 'rU') as f: + self.assertEqual(out.getvalue(), "Logging results to: " + log_file + "\n") + with open(log_file, "rU") as f: text = f.read() self.assertEqual(text, "formatted output") try: import tempfile # setUp + temp_dir = tempfile.mkdtemp() - log_dir = os.path.join(temp_dir, 'sub-dir/') - driver = BenchmarkDriver(Stub(), tests=['']) + log_dir = os.path.join(temp_dir, "sub-dir/") + driver = BenchmarkDriver(Stub(), tests=[""]) self.assertFalse(os.path.exists(log_dir)) content = "formatted output" - log_file = os.path.join(log_dir, '1.log') + log_file = os.path.join(log_dir, "1.log") with captured_output() as (out, _): driver.log_results(content, log_file=log_file) assert_log_written(out, log_file, content) self.assertTrue(os.path.exists(log_dir)) - log_file = os.path.join(log_dir, '2.log') + log_file = os.path.join(log_dir, "2.log") with captured_output() as (out, _): driver.log_results(content, log_file=log_file) assert_log_written(out, log_file, content) finally: import shutil # tearDown + shutil.rmtree(temp_dir) def test_deterministing_hashing(self): - cmd = ['printenv', 'SWIFT_DETERMINISTIC_HASHING'] - driver = BenchmarkDriver(['no args'], tests=['ignored']) - self.assertEqual(driver._invoke(cmd).strip(), '1') + cmd = ["printenv", "SWIFT_DETERMINISTIC_HASHING"] + driver = BenchmarkDriver(["no args"], tests=["ignored"]) + self.assertEqual(driver._invoke(cmd).strip(), "1") class BenchmarkDriverMock(Mock): """Mock for BenchmarkDriver's `run` method""" + def __init__(self, tests, responses=None): super(BenchmarkDriverMock, self).__init__(responses) self.tests = tests self.args = ArgsStub() - def _run(test, num_samples=None, num_iters=None, - verbose=None, measure_memory=False): - return self.record_and_respond(test, num_samples, num_iters, - verbose, measure_memory) + def _run( + test, num_samples=None, num_iters=None, verbose=None, measure_memory=False + ): + return self.record_and_respond( + test, num_samples, num_iters, verbose, measure_memory + ) + self.run = _run - def record_and_respond(self, test, num_samples, num_iters, - verbose, measure_memory): + def record_and_respond(self, test, num_samples, num_iters, verbose, measure_memory): args = (test, num_samples, num_iters, verbose, measure_memory) self.calls.append(args) return self.respond.get(args, _PTR(min=700)) @@ -432,35 +472,53 @@ def record_and_respond(self, test, num_samples, num_iters, class TestLoggingReportFormatter(unittest.TestCase): def test_plain_log_format(self): - lr = logging.makeLogRecord({ - 'name': 'Base.category', 'level': logging.DEBUG, - 'levelname': 'DEBUG', 'msg': 'Hi!'}) + lr = logging.makeLogRecord( + { + "name": "Base.category", + "level": logging.DEBUG, + "levelname": "DEBUG", + "msg": "Hi!", + } + ) f = LoggingReportFormatter() - self.assertEqual(f.format(lr), 'DEBUG category: Hi!') + self.assertEqual(f.format(lr), "DEBUG category: Hi!") def test_colored_log_format(self): def record(level, level_name): - return logging.makeLogRecord({ - 'name': 'Base.category', 'levelno': level, - 'levelname': level_name, 'msg': 'Hi!'}) + return logging.makeLogRecord( + { + "name": "Base.category", + "levelno": level, + "levelname": level_name, + "msg": "Hi!", + } + ) + f = LoggingReportFormatter(use_color=True) - self.assertEqual(f.format(record(logging.DEBUG, 'DEBUG')), - '\x1b[1;39mcategory: Hi!\x1b[1;0m') - self.assertEqual(f.format(record(logging.INFO, 'INFO')), - '\x1b[1;32mcategory: Hi!\x1b[1;0m') - self.assertEqual(f.format(record(logging.WARNING, 'WARNING')), - '\x1b[1;33mcategory: Hi!\x1b[1;0m') - self.assertEqual(f.format(record(logging.ERROR, 'ERROR')), - '\x1b[1;31mcategory: Hi!\x1b[1;0m') - self.assertEqual(f.format(record(logging.CRITICAL, 'CRITICAL')), - '\x1b[1;35mcategory: Hi!\x1b[1;0m') + self.assertEqual( + f.format(record(logging.DEBUG, "DEBUG")), "\x1b[1;39mcategory: Hi!\x1b[1;0m" + ) + self.assertEqual( + f.format(record(logging.INFO, "INFO")), "\x1b[1;32mcategory: Hi!\x1b[1;0m" + ) + self.assertEqual( + f.format(record(logging.WARNING, "WARNING")), + "\x1b[1;33mcategory: Hi!\x1b[1;0m", + ) + self.assertEqual( + f.format(record(logging.ERROR, "ERROR")), "\x1b[1;31mcategory: Hi!\x1b[1;0m" + ) + self.assertEqual( + f.format(record(logging.CRITICAL, "CRITICAL")), + "\x1b[1;35mcategory: Hi!\x1b[1;0m", + ) def test_no_prefix_for_base_logging(self): - lr = logging.makeLogRecord({ - 'name': 'Base', 'level': logging.INFO, - 'levelname': 'INFO', 'msg': 'Hi!'}) + lr = logging.makeLogRecord( + {"name": "Base", "level": logging.INFO, "levelname": "INFO", "msg": "Hi!"} + ) f = LoggingReportFormatter() - self.assertEqual(f.format(lr), 'INFO Hi!') + self.assertEqual(f.format(lr), "INFO Hi!") class TestMarkdownReportHandler(unittest.TestCase): @@ -475,44 +533,41 @@ def assert_contains(self, texts): self.assertIn(text, self.stream.getvalue()) def record(self, level, category, msg): - return logging.makeLogRecord({ - 'name': 'BenchmarkDoctor.' + category, - 'levelno': level, 'msg': msg}) + return logging.makeLogRecord( + {"name": "BenchmarkDoctor." + category, "levelno": level, "msg": msg} + ) def test_init_writes_table_header(self): self.assertEqual(self.handler.level, logging.INFO) - self.assert_contains(['Benchmark Check Report\n', '---|---']) + self.assert_contains(["Benchmark Check Report\n", "---|---"]) def test_close_writes_final_newlines(self): self.handler.close() - self.assert_contains(['---|---\n\n']) + self.assert_contains(["---|---\n\n"]) def test_errors_and_warnings_start_new_rows_with_icons(self): - self.handler.emit(self.record(logging.ERROR, '', 'Blunder')) - self.handler.emit(self.record(logging.WARNING, '', 'Boo-boo')) - self.assert_contains(['\n⛔️ | Blunder', - '\n⚠️ | Boo-boo']) + self.handler.emit(self.record(logging.ERROR, "", "Blunder")) + self.handler.emit(self.record(logging.WARNING, "", "Boo-boo")) + self.assert_contains(["\n⛔️ | Blunder", "\n⚠️ | Boo-boo"]) def test_category_icons(self): - self.handler.emit(self.record(logging.WARNING, 'naming', 'naming')) - self.handler.emit(self.record(logging.WARNING, 'runtime', 'runtime')) - self.handler.emit(self.record(logging.WARNING, 'memory', 'memory')) - self.assert_contains(['🔤 | naming', - '⏱ | runtime', - 'Ⓜ️ | memory']) + self.handler.emit(self.record(logging.WARNING, "naming", "naming")) + self.handler.emit(self.record(logging.WARNING, "runtime", "runtime")) + self.handler.emit(self.record(logging.WARNING, "memory", "memory")) + self.assert_contains(["🔤 | naming", "⏱ | runtime", "Ⓜ️ | memory"]) def test_info_stays_in_table_cell_breaking_line_row_to_subscript(self): """Assuming Infos only follow after Errors and Warnings. Infos don't emit category icons. """ - self.handler.emit(self.record(logging.ERROR, 'naming', 'Blunder')) - self.handler.emit(self.record(logging.INFO, 'naming', 'Fixit')) - self.assert_contains(['Blunder
Fixit']) + self.handler.emit(self.record(logging.ERROR, "naming", "Blunder")) + self.handler.emit(self.record(logging.INFO, "naming", "Fixit")) + self.assert_contains(["Blunder
Fixit"]) def test_names_in_code_format(self): - self.handler.emit(self.record(logging.WARNING, '', "'QuotedName'")) - self.assert_contains(['| `QuotedName`']) + self.handler.emit(self.record(logging.WARNING, "", "'QuotedName'")) + self.assert_contains(["| `QuotedName`"]) def _PTR(min=700, mem_pages=1000, setup=None): @@ -520,19 +575,17 @@ def _PTR(min=700, mem_pages=1000, setup=None): return Stub(samples=Stub(min=min), mem_pages=mem_pages, setup=setup) -def _run(test, num_samples=None, num_iters=None, verbose=None, - measure_memory=False): +def _run(test, num_samples=None, num_iters=None, verbose=None, measure_memory=False): """Helper function that constructs tuple with arguments for run method.""" - return ( - test, num_samples, num_iters, verbose, measure_memory) + return (test, num_samples, num_iters, verbose, measure_memory) class TestBenchmarkDoctor(unittest.TestCase): @classmethod def setUpClass(cls): super(TestBenchmarkDoctor, cls).setUpClass() - doctor_log = logging.getLogger('BenchmarkDoctor') - cls._doctor_log_handler = MockLoggingHandler(level='DEBUG') + doctor_log = logging.getLogger("BenchmarkDoctor") + cls._doctor_log_handler = MockLoggingHandler(level="DEBUG") doctor_log.addHandler(cls._doctor_log_handler) def setUp(self): @@ -547,34 +600,33 @@ def assert_contains(self, texts, output): self.assertIn(text, output) def test_uses_logging(self): - driver = BenchmarkDriverMock(tests=['B1', 'B2']) + driver = BenchmarkDriverMock(tests=["B1", "B2"]) with captured_output() as (out, _): BenchmarkDoctor(self.args, driver) - self.assert_contains(['Checking tests: B1, B2'], self.logs['debug']) - self.assertEqual(out.getvalue(), '') + self.assert_contains(["Checking tests: B1, B2"], self.logs["debug"]) + self.assertEqual(out.getvalue(), "") def test_supports_verbose_output(self): - driver = BenchmarkDriverMock(tests=['B1', 'B2']) + driver = BenchmarkDriverMock(tests=["B1", "B2"]) driver.verbose = True self.args.verbose = True with captured_output() as (out, _): BenchmarkDoctor(self.args, driver) - self.assert_contains(['Checking tests: B1, B2'], out.getvalue()) + self.assert_contains(["Checking tests: B1, B2"], out.getvalue()) def test_uses_report_formatter(self): - doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock(tests=['B1'])) - console_handler = logging.getLogger('BenchmarkDoctor').handlers[1] + doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock(tests=["B1"])) + console_handler = logging.getLogger("BenchmarkDoctor").handlers[1] self.assertTrue(doctor) self.assertTrue(isinstance(console_handler, logging.StreamHandler)) - self.assertTrue(isinstance(console_handler.formatter, - LoggingReportFormatter)) + self.assertTrue(isinstance(console_handler.formatter, LoggingReportFormatter)) def test_uses_optional_markdown_report_formatter(self): self.args.markdown = True with captured_output() as (_, _): - doc = BenchmarkDoctor(self.args, BenchmarkDriverMock(tests=['B1'])) + doc = BenchmarkDoctor(self.args, BenchmarkDriverMock(tests=["B1"])) self.assertTrue(doc) - console_handler = logging.getLogger('BenchmarkDoctor').handlers[1] + console_handler = logging.getLogger("BenchmarkDoctor").handlers[1] self.assertTrue(isinstance(console_handler, MarkdownReportHandler)) def test_measure_10_independent_1s_benchmark_series(self): @@ -584,86 +636,155 @@ def test_measure_10_independent_1s_benchmark_series(self): take measurements for approximately 1s based on short initial runtime sampling. Capped at 200 samples. """ - driver = BenchmarkDriverMock(tests=['B1'], responses=([ - # calibration run, returns a stand-in for PerformanceTestResult - (_run('B1', num_samples=3, num_iters=1, - verbose=True), _PTR(min=300))] + - # 5x i1 series, with 300 μs runtime its possible to take 4098 - # samples/s, but it should be capped at 2k - ([(_run('B1', num_samples=200, num_iters=1, - verbose=True, measure_memory=True), _PTR(min=300))] * 5) + - # 5x i2 series - ([(_run('B1', num_samples=200, num_iters=2, - verbose=True, measure_memory=True), _PTR(min=300))] * 5) - )) + driver = BenchmarkDriverMock( + tests=["B1"], + responses=( + [ + # calibration run, returns a stand-in for PerformanceTestResult + ( + _run("B1", num_samples=3, num_iters=1, verbose=True), + _PTR(min=300), + ) + ] + + + # 5x i1 series, with 300 μs runtime its possible to take 4098 + # samples/s, but it should be capped at 2k + ( + [ + ( + _run( + "B1", + num_samples=200, + num_iters=1, + verbose=True, + measure_memory=True, + ), + _PTR(min=300), + ) + ] + * 5 + ) + + + # 5x i2 series + ( + [ + ( + _run( + "B1", + num_samples=200, + num_iters=2, + verbose=True, + measure_memory=True, + ), + _PTR(min=300), + ) + ] + * 5 + ) + ), + ) doctor = BenchmarkDoctor(self.args, driver) with captured_output() as (out, _): - measurements = doctor.measure('B1') + measurements = doctor.measure("B1") driver.assert_called_all_expected() self.assert_contains( - ['name', - 'B1 O i1a', 'B1 O i1b', 'B1 O i1c', 'B1 O i1d', 'B1 O i1e', - 'B1 O i2a', 'B1 O i2b', 'B1 O i2c', 'B1 O i2d', 'B1 O i2e'], - measurements.keys()) - self.assertEqual(measurements['name'], 'B1') + [ + "name", + "B1 O i1a", + "B1 O i1b", + "B1 O i1c", + "B1 O i1d", + "B1 O i1e", + "B1 O i2a", + "B1 O i2b", + "B1 O i2c", + "B1 O i2d", + "B1 O i2e", + ], + measurements.keys(), + ) + self.assertEqual(measurements["name"], "B1") self.assert_contains( - ['Calibrating num-samples for B1:', - 'Runtime 300 μs yields 4096 adjusted samples per second.', - 'Measuring B1, 5 x i1 (200 samples), 5 x i2 (200 samples)'], - self.logs['debug']) + [ + "Calibrating num-samples for B1:", + "Runtime 300 μs yields 4096 adjusted samples per second.", + "Measuring B1, 5 x i1 (200 samples), 5 x i2 (200 samples)", + ], + self.logs["debug"], + ) def test_benchmark_name_matches_naming_conventions(self): - driver = BenchmarkDriverMock(tests=[ - 'BenchmarkName', 'CapitalWordsConvention', 'ABBRName', - 'TooManyCamelCaseHumps', - 'Existential.Array.method.1x.Val4', - 'Flatten.Array.Array.Str.for-in.reserved', - 'Flatten.Array.String?.as!.NSArray', - 'wrongCase', 'Wrong_convention', 'Illegal._$%[]<>{}@^()']) + driver = BenchmarkDriverMock( + tests=[ + "BenchmarkName", + "CapitalWordsConvention", + "ABBRName", + "TooManyCamelCaseHumps", + "Existential.Array.method.1x.Val4", + "Flatten.Array.Array.Str.for-in.reserved", + "Flatten.Array.String?.as!.NSArray", + "wrongCase", + "Wrong_convention", + "Illegal._$%[]<>{}@^()", + ] + ) with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, driver) doctor.check() output = out.getvalue() - self.assertIn('naming: ', output) - self.assertNotIn('BenchmarkName', output) - self.assertNotIn('CapitalWordsConvention', output) - self.assertNotIn('ABBRName', output) - self.assertNotIn('Existential.Array.method.1x.Val4', output) - self.assertNotIn('Flatten.Array.Array.Str.for-in.reserved', output) - self.assertNotIn('Flatten.Array.String?.as!.NSArray', output) + self.assertIn("naming: ", output) + self.assertNotIn("BenchmarkName", output) + self.assertNotIn("CapitalWordsConvention", output) + self.assertNotIn("ABBRName", output) + self.assertNotIn("Existential.Array.method.1x.Val4", output) + self.assertNotIn("Flatten.Array.Array.Str.for-in.reserved", output) + self.assertNotIn("Flatten.Array.String?.as!.NSArray", output) err_msg = " name doesn't conform to benchmark naming convention." self.assert_contains( - ["'wrongCase'" + err_msg, "'Wrong_convention'" + err_msg, - "'Illegal._$%[]<>{}@^()'" + err_msg], self.logs['error']) + [ + "'wrongCase'" + err_msg, + "'Wrong_convention'" + err_msg, + "'Illegal._$%[]<>{}@^()'" + err_msg, + ], + self.logs["error"], + ) self.assert_contains( ["'TooManyCamelCaseHumps' name is composed of 5 words."], - self.logs['warning']) + self.logs["warning"], + ) + self.assert_contains(["See http://bit.ly/BenchmarkNaming"], self.logs["info"]) self.assert_contains( - ['See http://bit.ly/BenchmarkNaming'], self.logs['info']) - self.assert_contains( - ["Split 'TooManyCamelCaseHumps' name into dot-separated groups " - "and variants. See http://bit.ly/BenchmarkNaming"], - self.logs['info']) + [ + "Split 'TooManyCamelCaseHumps' name into dot-separated groups " + "and variants. See http://bit.ly/BenchmarkNaming" + ], + self.logs["info"], + ) def test_benchmark_name_is_at_most_40_chars_long(self): - driver = BenchmarkDriverMock(tests=[ - 'BenchmarkName', - 'ThisTestNameIsTooLongAndCausesOverflowsInReports']) + driver = BenchmarkDriverMock( + tests=["BenchmarkName", "ThisTestNameIsTooLongAndCausesOverflowsInReports"] + ) with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, driver) doctor.check() output = out.getvalue() - self.assertIn('naming: ', output) - self.assertNotIn('BenchmarkName', output) + self.assertIn("naming: ", output) + self.assertNotIn("BenchmarkName", output) self.assert_contains( - ["'ThisTestNameIsTooLongAndCausesOverflowsInReports' name is " - "48 characters long."], self.logs['error']) + [ + "'ThisTestNameIsTooLongAndCausesOverflowsInReports' name is " + "48 characters long." + ], + self.logs["error"], + ) self.assert_contains( ["Benchmark name should not be longer than 40 characters."], - self.logs['info']) + self.logs["info"], + ) def test_benchmark_runtime_range(self): """Optimized benchmark should have runtime between 20 μs and 1000 μs. @@ -679,159 +800,226 @@ def test_benchmark_runtime_range(self): Warn about longer runtime. Runtimes over 10ms are an error. """ + def measurements(name, runtime): - return {'name': name, - name + ' O i1a': _PTR(min=runtime + 2), - name + ' O i2a': _PTR(min=runtime)} + return { + "name": name, + name + " O i1a": _PTR(min=runtime + 2), + name + " O i2a": _PTR(min=runtime), + } with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock([])) - doctor.analyze(measurements('Sylph', 0)) - doctor.analyze(measurements('Unicorn', 3)) - doctor.analyze(measurements('Cheetah', 200)) - doctor.analyze(measurements('Hare', 1001)) - doctor.analyze(measurements('Tortoise', 500000)) - doctor.analyze({'name': 'OverheadTurtle', - 'OverheadTurtle O i1a': _PTR(min=800000), - 'OverheadTurtle O i2a': _PTR(min=700000)}) + doctor.analyze(measurements("Sylph", 0)) + doctor.analyze(measurements("Unicorn", 3)) + doctor.analyze(measurements("Cheetah", 200)) + doctor.analyze(measurements("Hare", 1001)) + doctor.analyze(measurements("Tortoise", 500000)) + doctor.analyze( + { + "name": "OverheadTurtle", + "OverheadTurtle O i1a": _PTR(min=800000), + "OverheadTurtle O i2a": _PTR(min=700000), + } + ) output = out.getvalue() - self.assertIn('runtime: ', output) - self.assertNotIn('Cheetah', output) - self.assert_contains(["'Sylph' execution took 0 μs."], - self.logs['error']) + self.assertIn("runtime: ", output) + self.assertNotIn("Cheetah", output) + self.assert_contains(["'Sylph' execution took 0 μs."], self.logs["error"]) self.assert_contains( - ["Ensure the workload of 'Sylph' has a properly measurable size" - " (runtime > 20 μs) and is not eliminated by the compiler (use " - "`blackHole` function if necessary)."], - self.logs['info']) - self.assert_contains(["'Unicorn' execution took 3 μs."], - self.logs['warning']) + [ + "Ensure the workload of 'Sylph' has a properly measurable size" + " (runtime > 20 μs) and is not eliminated by the compiler (use " + "`blackHole` function if necessary)." + ], + self.logs["info"], + ) + self.assert_contains(["'Unicorn' execution took 3 μs."], self.logs["warning"]) self.assert_contains( ["Increase the workload of 'Unicorn' to be more than 20 μs."], - self.logs['info']) - self.assert_contains(["'Hare' execution took at least 1001 μs."], - self.logs['warning']) + self.logs["info"], + ) + self.assert_contains( + ["'Hare' execution took at least 1001 μs."], self.logs["warning"] + ) self.assert_contains( - ["Decrease the workload of 'Hare' by a factor of 2 (10), " - "to be less than 1000 μs."], self.logs['info']) + [ + "Decrease the workload of 'Hare' by a factor of 2 (10), " + "to be less than 1000 μs." + ], + self.logs["info"], + ) self.assert_contains( - ["'Tortoise' execution took at least 500000 μs."], - self.logs['error']) + ["'Tortoise' execution took at least 500000 μs."], self.logs["error"] + ) self.assert_contains( - ["Decrease the workload of 'Tortoise' by a factor of 512 (1000), " - "to be less than 1000 μs."], self.logs['info']) + [ + "Decrease the workload of 'Tortoise' by a factor of 512 (1000), " + "to be less than 1000 μs." + ], + self.logs["info"], + ) self.assert_contains( - ["'OverheadTurtle' execution took at least 600000 μs" - " (excluding the setup overhead)."], - self.logs['error']) + [ + "'OverheadTurtle' execution took at least 600000 μs" + " (excluding the setup overhead)." + ], + self.logs["error"], + ) def test_benchmark_has_no_significant_setup_overhead(self): with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock([])) - doctor.analyze({ - 'name': 'NoOverhead', # not 'significant' enough - # Based on DropFirstArray a10/e10: overhead 3.7% (6 μs) - 'NoOverhead O i1a': _PTR(min=162), - 'NoOverhead O i2a': _PTR(min=159)}) - doctor.analyze({ - 'name': 'SO', # Setup Overhead - # Based on SuffixArrayLazy a10/e10: overhead 5.8% (4 μs) - 'SO O i1a': _PTR(min=69), 'SO O i1b': _PTR(min=70), - 'SO O i2a': _PTR(min=67), 'SO O i2b': _PTR(min=68)}) - doctor.analyze({'name': 'Zero', 'Zero O i1a': _PTR(min=0), - 'Zero O i2a': _PTR(min=0)}) - doctor.analyze({ - 'name': 'LOA', # Limit of Accuracy - # Impossible to detect overhead: - # Even 1μs change in 20μs runtime is 5%. - 'LOA O i1a': _PTR(min=21), - 'LOA O i2a': _PTR(min=20)}) + doctor.analyze( + { + "name": "NoOverhead", # not 'significant' enough + # Based on DropFirstArray a10/e10: overhead 3.7% (6 μs) + "NoOverhead O i1a": _PTR(min=162), + "NoOverhead O i2a": _PTR(min=159), + } + ) + doctor.analyze( + { + "name": "SO", # Setup Overhead + # Based on SuffixArrayLazy a10/e10: overhead 5.8% (4 μs) + "SO O i1a": _PTR(min=69), + "SO O i1b": _PTR(min=70), + "SO O i2a": _PTR(min=67), + "SO O i2b": _PTR(min=68), + } + ) + doctor.analyze( + {"name": "Zero", "Zero O i1a": _PTR(min=0), "Zero O i2a": _PTR(min=0)} + ) + doctor.analyze( + { + "name": "LOA", # Limit of Accuracy + # Impossible to detect overhead: + # Even 1μs change in 20μs runtime is 5%. + "LOA O i1a": _PTR(min=21), + "LOA O i2a": _PTR(min=20), + } + ) output = out.getvalue() - self.assertIn('runtime: ', output) - self.assertNotIn('NoOverhead', output) - self.assertNotIn('ZeroRuntime', output) - self.assertNotIn('LOA', output) + self.assertIn("runtime: ", output) + self.assertNotIn("NoOverhead", output) + self.assertNotIn("ZeroRuntime", output) + self.assertNotIn("LOA", output) self.assert_contains( - ["'SO' has setup overhead of 4 μs (5.8%)."], - self.logs['error']) + ["'SO' has setup overhead of 4 μs (5.8%)."], self.logs["error"] + ) self.assert_contains( - ["Move initialization of benchmark data to the `setUpFunction` " - "registered in `BenchmarkInfo`."], self.logs['info']) + [ + "Move initialization of benchmark data to the `setUpFunction` " + "registered in `BenchmarkInfo`." + ], + self.logs["info"], + ) def test_benchmark_setup_takes_reasonable_time(self): """Setup < 200 ms (20% extra on top of the typical 1 s measurement)""" with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock([])) - doctor.analyze({ - 'name': 'NormalSetup', - 'NormalSetup O i1a': _PTR(setup=199999), - 'NormalSetup O i2a': _PTR(setup=200001)}) - doctor.analyze({ - 'name': 'LongSetup', - 'LongSetup O i1a': _PTR(setup=200001), - 'LongSetup O i2a': _PTR(setup=200002)}) + doctor.analyze( + { + "name": "NormalSetup", + "NormalSetup O i1a": _PTR(setup=199999), + "NormalSetup O i2a": _PTR(setup=200001), + } + ) + doctor.analyze( + { + "name": "LongSetup", + "LongSetup O i1a": _PTR(setup=200001), + "LongSetup O i2a": _PTR(setup=200002), + } + ) output = out.getvalue() - self.assertIn('runtime: ', output) - self.assertNotIn('NormalSetup', output) + self.assertIn("runtime: ", output) + self.assertNotIn("NormalSetup", output) self.assert_contains( - ["'LongSetup' setup took at least 200001 μs."], - self.logs['error']) + ["'LongSetup' setup took at least 200001 μs."], self.logs["error"] + ) self.assert_contains( - ["The `setUpFunction` should take no more than 200 ms."], - self.logs['info']) + ["The `setUpFunction` should take no more than 200 ms."], self.logs["info"] + ) def test_benchmark_has_constant_memory_use(self): """Benchmark's memory footprint must not vary with num-iters.""" with captured_output() as (out, _): doctor = BenchmarkDoctor(self.args, BenchmarkDriverMock([])) - doctor.analyze({ - # The threshold of 15 pages was estimated from previous - # measurements. The normal range should be probably aproximated - # by a function instead of a simple constant. - # TODO: re-evaluate normal range from whole SBS - 'name': 'ConstantMemory', - 'ConstantMemory O i1a': _PTR(mem_pages=1460), - 'ConstantMemory O i2a': _PTR(mem_pages=(1460 + 15))}) - doctor.analyze({ - 'name': 'VariableMemory', # ObserverForwardStruct - 'VariableMemory O i1a': _PTR(mem_pages=1460), - 'VariableMemory O i1b': _PTR(mem_pages=1472), - # i2 series start at 290 pages higher - 'VariableMemory O i2a': _PTR(mem_pages=1750), - 'VariableMemory O i2b': _PTR(mem_pages=1752)}) - measurements = dict([ - ('HighVariance O i{0}{1}'.format(num_iters, suffix), - _PTR(mem_pages=num_pages)) - for num_iters, pages in [ - (1, [6200, 5943, 4818, 5612, 5469]), - (2, [6244, 5832, 4674, 5176, 5490])] - for num_pages, suffix in zip(pages, list('abcde'))]) - measurements['name'] = 'HighVariance' # Array2D + doctor.analyze( + { + # The threshold of 15 pages was estimated from previous + # measurements. The normal range should be probably aproximated + # by a function instead of a simple constant. + # TODO: re-evaluate normal range from whole SBS + "name": "ConstantMemory", + "ConstantMemory O i1a": _PTR(mem_pages=1460), + "ConstantMemory O i2a": _PTR(mem_pages=(1460 + 15)), + } + ) + doctor.analyze( + { + "name": "VariableMemory", # ObserverForwardStruct + "VariableMemory O i1a": _PTR(mem_pages=1460), + "VariableMemory O i1b": _PTR(mem_pages=1472), + # i2 series start at 290 pages higher + "VariableMemory O i2a": _PTR(mem_pages=1750), + "VariableMemory O i2b": _PTR(mem_pages=1752), + } + ) + measurements = dict( + [ + ( + "HighVariance O i{0}{1}".format(num_iters, suffix), + _PTR(mem_pages=num_pages), + ) + for num_iters, pages in [ + (1, [6200, 5943, 4818, 5612, 5469]), + (2, [6244, 5832, 4674, 5176, 5490]), + ] + for num_pages, suffix in zip(pages, list("abcde")) + ] + ) + measurements["name"] = "HighVariance" # Array2D doctor.analyze(measurements) output = out.getvalue() - self.assertIn('memory: ', output) - self.assertNotIn('ConstantMemory', output) + self.assertIn("memory: ", output) + self.assertNotIn("ConstantMemory", output) self.assert_contains( - ["'VariableMemory' varies the memory footprint of the base " - "workload depending on the `num-iters`."], - self.logs['error']) + [ + "'VariableMemory' varies the memory footprint of the base " + "workload depending on the `num-iters`." + ], + self.logs["error"], + ) self.assert_contains( - ["'VariableMemory' " - "mem_pages [i1, i2]: min=[1460, 1750] 𝚫=290 R=[12, 2]"], - self.logs['info']) + [ + "'VariableMemory' " + "mem_pages [i1, i2]: min=[1460, 1750] 𝚫=290 R=[12, 2]" + ], + self.logs["info"], + ) self.assert_contains( - ["'HighVariance' has very wide range of memory used between " - "independent, repeated measurements."], - self.logs['warning']) + [ + "'HighVariance' has very wide range of memory used between " + "independent, repeated measurements." + ], + self.logs["warning"], + ) self.assert_contains( - ["'HighVariance' " - "mem_pages [i1, i2]: min=[4818, 4674] 𝚫=144 R=[1382, 1570]"], - self.logs['info']) + [ + "'HighVariance' " + "mem_pages [i1, i2]: min=[4818, 4674] 𝚫=144 R=[1382, 1570]" + ], + self.logs["info"], + ) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/benchmark/scripts/test_compare_perf_tests.py b/benchmark/scripts/test_compare_perf_tests.py index 4c1c6effffcd5..2053e93c0b42b 100644 --- a/benchmark/scripts/test_compare_perf_tests.py +++ b/benchmark/scripts/test_compare_perf_tests.py @@ -48,11 +48,11 @@ def test_is_iterable(self): class TestPerformanceTestSamples(unittest.TestCase): def setUp(self): - self.samples = PerformanceTestSamples('B1') + self.samples = PerformanceTestSamples("B1") self.samples.add(Sample(7, 42, 1000)) def test_has_name(self): - self.assertEqual(self.samples.name, 'B1') + self.assertEqual(self.samples.name, "B1") def test_stores_samples(self): self.assertEqual(self.samples.count, 1) @@ -70,7 +70,7 @@ def test_quantile(self): self.assertEqual(self.samples.quantile(1), 1100) self.samples.add(Sample(3, 1, 1050)) self.assertEqual(self.samples.quantile(0), 1000) - self.assertEqual(self.samples.quantile(.5), 1050) + self.assertEqual(self.samples.quantile(0.5), 1050) self.assertEqual(self.samples.quantile(1), 1100) def assertEqualFiveNumberSummary(self, ss, expected_fns): @@ -82,20 +82,15 @@ def assertEqualFiveNumberSummary(self, ss, expected_fns): self.assertEqual(ss.max, e_max) def test_computes_five_number_summary(self): - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1000, 1000, 1000, 1000)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1000, 1000, 1000, 1000)) self.samples.add(Sample(2, 1, 1100)) - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1000, 1000, 1100, 1100)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1000, 1000, 1100, 1100)) self.samples.add(Sample(3, 1, 1050)) - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1000, 1050, 1100, 1100)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1000, 1050, 1100, 1100)) self.samples.add(Sample(4, 1, 1025)) - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1000, 1025, 1050, 1100)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1000, 1025, 1050, 1100)) self.samples.add(Sample(5, 1, 1075)) - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1025, 1050, 1075, 1100)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1025, 1050, 1075, 1100)) def test_computes_inter_quartile_range(self): self.assertEqual(self.samples.iqr, 0) @@ -111,59 +106,66 @@ def assertEqualtats(self, stats, expected_stats): def test_computes_mean_sd_cv(self): ss = self.samples - self.assertEqualtats( - (ss.mean, ss.sd, ss.cv), (1000.0, 0.0, 0.0)) + self.assertEqualtats((ss.mean, ss.sd, ss.cv), (1000.0, 0.0, 0.0)) self.samples.add(Sample(2, 1, 1100)) - self.assertEqualtats( - (ss.mean, ss.sd, ss.cv), (1050.0, 70.71, 6.7 / 100)) + self.assertEqualtats((ss.mean, ss.sd, ss.cv), (1050.0, 70.71, 6.7 / 100)) def test_computes_range_spread(self): ss = self.samples - self.assertEqualtats( - (ss.range, ss.spread), (0, 0)) + self.assertEqualtats((ss.range, ss.spread), (0, 0)) self.samples.add(Sample(2, 1, 1100)) - self.assertEqualtats( - (ss.range, ss.spread), (100, 10.0 / 100)) + self.assertEqualtats((ss.range, ss.spread), (100, 10.0 / 100)) def test_init_with_samples(self): self.samples = PerformanceTestSamples( - 'B2', [Sample(0, 1, 1000), Sample(1, 1, 1100)]) + "B2", [Sample(0, 1, 1000), Sample(1, 1, 1100)] + ) self.assertEqual(self.samples.count, 2) self.assertEqualtats( - (self.samples.mean, self.samples.sd, - self.samples.range, self.samples.spread), - (1050.0, 70.71, 100, 9.52 / 100)) + ( + self.samples.mean, + self.samples.sd, + self.samples.range, + self.samples.spread, + ), + (1050.0, 70.71, 100, 9.52 / 100), + ) def test_can_handle_zero_runtime(self): # guard against dividing by 0 - self.samples = PerformanceTestSamples('Zero') + self.samples = PerformanceTestSamples("Zero") self.samples.add(Sample(0, 1, 0)) self.assertEqualtats( - (self.samples.mean, self.samples.sd, self.samples.cv, - self.samples.range, self.samples.spread), - (0, 0, 0.0, 0, 0.0)) + ( + self.samples.mean, + self.samples.sd, + self.samples.cv, + self.samples.range, + self.samples.spread, + ), + (0, 0, 0.0, 0, 0.0), + ) def test_excludes_outliers(self): - ss = [Sample(*map(int, s.split())) for s in - '0 1 1000, 1 1 1025, 2 1 1050, 3 1 1075, 4 1 1100, ' - '5 1 1000, 6 1 1025, 7 1 1050, 8 1 1075, 9 1 1100, ' - '10 1 1050, 11 1 949, 12 1 1151'.split(',')] - self.samples = PerformanceTestSamples('Outliers', ss) + ss = [ + Sample(*map(int, s.split())) + for s in "0 1 1000, 1 1 1025, 2 1 1050, 3 1 1075, 4 1 1100, " + "5 1 1000, 6 1 1025, 7 1 1050, 8 1 1075, 9 1 1100, " + "10 1 1050, 11 1 949, 12 1 1151".split(",") + ] + self.samples = PerformanceTestSamples("Outliers", ss) self.assertEqual(self.samples.count, 13) - self.assertEqualtats( - (self.samples.mean, self.samples.sd), (1050, 52.36)) + self.assertEqualtats((self.samples.mean, self.samples.sd), (1050, 52.36)) self.samples.exclude_outliers() self.assertEqual(self.samples.count, 11) self.assertEqual(self.samples.outliers, ss[11:]) - self.assertEqualFiveNumberSummary( - self.samples, (1000, 1025, 1050, 1075, 1100)) - self.assertEqualtats( - (self.samples.mean, self.samples.sd), (1050, 35.36)) + self.assertEqualFiveNumberSummary(self.samples, (1000, 1025, 1050, 1075, 1100)) + self.assertEqualtats((self.samples.mean, self.samples.sd), (1050, 35.36)) def test_excludes_outliers_zero_IQR(self): - self.samples = PerformanceTestSamples('Tight') + self.samples = PerformanceTestSamples("Tight") self.samples.add(Sample(0, 2, 23)) self.samples.add(Sample(1, 2, 18)) self.samples.add(Sample(2, 2, 18)) @@ -173,13 +175,14 @@ def test_excludes_outliers_zero_IQR(self): self.samples.exclude_outliers() self.assertEqual(self.samples.count, 3) - self.assertEqualtats( - (self.samples.min, self.samples.max), (18, 18)) + self.assertEqualtats((self.samples.min, self.samples.max), (18, 18)) def test_excludes_outliers_top_only(self): - ss = [Sample(*map(int, s.split())) for s in - '0 1 1, 1 1 2, 2 1 2, 3 1 2, 4 1 3'.split(',')] - self.samples = PerformanceTestSamples('Top', ss) + ss = [ + Sample(*map(int, s.split())) + for s in "0 1 1, 1 1 2, 2 1 2, 3 1 2, 4 1 3".split(",") + ] + self.samples = PerformanceTestSamples("Top", ss) self.assertEqualFiveNumberSummary(self.samples, (1, 2, 2, 2, 3)) self.assertEqual(self.samples.iqr, 0) @@ -191,48 +194,52 @@ def test_excludes_outliers_top_only(self): class TestPerformanceTestResult(unittest.TestCase): def test_init(self): - log_line = '1,AngryPhonebook,20,10664,12933,11035,576,10884' - r = PerformanceTestResult(log_line.split(',')) - self.assertEqual(r.test_num, '1') - self.assertEqual(r.name, 'AngryPhonebook') + log_line = "1,AngryPhonebook,20,10664,12933,11035,576,10884" + r = PerformanceTestResult(log_line.split(",")) + self.assertEqual(r.test_num, "1") + self.assertEqual(r.name, "AngryPhonebook") self.assertEqual( (r.num_samples, r.min, r.max, r.mean, r.sd, r.median), - (20, 10664, 12933, 11035, 576, 10884)) + (20, 10664, 12933, 11035, 576, 10884), + ) self.assertEqual(r.samples, None) - log_line = '1,AngryPhonebook,1,12045,12045,12045,0,12045,10510336' - r = PerformanceTestResult(log_line.split(',')) + log_line = "1,AngryPhonebook,1,12045,12045,12045,0,12045,10510336" + r = PerformanceTestResult(log_line.split(",")) self.assertEqual(r.max_rss, 10510336) def test_init_quantiles(self): # #,TEST,SAMPLES,MIN(μs),MEDIAN(μs),MAX(μs) - log = '1,Ackermann,3,54383,54512,54601' - r = PerformanceTestResult(log.split(','), quantiles=True) - self.assertEqual(r.test_num, '1') - self.assertEqual(r.name, 'Ackermann') - self.assertEqual((r.num_samples, r.min, r.median, r.max), - (3, 54383, 54512, 54601)) + log = "1,Ackermann,3,54383,54512,54601" + r = PerformanceTestResult(log.split(","), quantiles=True) + self.assertEqual(r.test_num, "1") + self.assertEqual(r.name, "Ackermann") + self.assertEqual( + (r.num_samples, r.min, r.median, r.max), (3, 54383, 54512, 54601) + ) self.assertAlmostEquals(r.mean, 54498.67, places=2) self.assertAlmostEquals(r.sd, 109.61, places=2) self.assertEqual(r.samples.count, 3) self.assertEqual(r.samples.num_samples, 3) - self.assertEqual([s.runtime for s in r.samples.all_samples], - [54383, 54512, 54601]) + self.assertEqual( + [s.runtime for s in r.samples.all_samples], [54383, 54512, 54601] + ) # #,TEST,SAMPLES,MIN(μs),MEDIAN(μs),MAX(μs),MAX_RSS(B) - log = '1,Ackermann,3,54529,54760,55807,266240' - r = PerformanceTestResult(log.split(','), quantiles=True, memory=True) + log = "1,Ackermann,3,54529,54760,55807,266240" + r = PerformanceTestResult(log.split(","), quantiles=True, memory=True) self.assertEqual((r.samples.count, r.max_rss), (3, 266240)) # #,TEST,SAMPLES,MIN(μs),Q1(μs),Q2(μs),Q3(μs),MAX(μs) - log = '1,Ackermann,5,54570,54593,54644,57212,58304' - r = PerformanceTestResult(log.split(','), quantiles=True, memory=False) - self.assertEqual((r.num_samples, r.min, r.median, r.max), - (5, 54570, 54644, 58304)) + log = "1,Ackermann,5,54570,54593,54644,57212,58304" + r = PerformanceTestResult(log.split(","), quantiles=True, memory=False) + self.assertEqual( + (r.num_samples, r.min, r.median, r.max), (5, 54570, 54644, 58304) + ) self.assertEqual((r.samples.q1, r.samples.q3), (54593, 57212)) self.assertEqual(r.samples.count, 5) # #,TEST,SAMPLES,MIN(μs),Q1(μs),Q2(μs),Q3(μs),MAX(μs),MAX_RSS(B) - log = '1,Ackermann,5,54686,54731,54774,55030,63466,270336' - r = PerformanceTestResult(log.split(','), quantiles=True, memory=True) + log = "1,Ackermann,5,54686,54731,54774,55030,63466,270336" + r = PerformanceTestResult(log.split(","), quantiles=True, memory=True) self.assertEqual(r.samples.num_samples, 5) self.assertEqual(r.samples.count, 4) # outlier was excluded self.assertEqual(r.max_rss, 270336) @@ -241,10 +248,9 @@ def test_init_delta_quantiles(self): # #,TEST,SAMPLES,MIN(μs),𝚫MEDIAN,𝚫MAX # 2-quantile from 2 samples in repeated min, when delta encoded, # the difference is 0, which is ommited -- only separator remains - log = '202,DropWhileArray,2,265,,22' - r = PerformanceTestResult(log.split(','), quantiles=True, delta=True) - self.assertEqual((r.num_samples, r.min, r.median, r.max), - (2, 265, 265, 287)) + log = "202,DropWhileArray,2,265,,22" + r = PerformanceTestResult(log.split(","), quantiles=True, delta=True) + self.assertEqual((r.num_samples, r.min, r.median, r.max), (2, 265, 265, 287)) self.assertEqual(r.samples.count, 2) self.assertEqual(r.samples.num_samples, 2) @@ -260,14 +266,17 @@ def test_init_oversampled_quantiles(self): qs <- subsample(x, s); c(qs[1], diff(qs)) })) sapply(c(3, 5, 11, 21), tbl) """ + def validatePTR(deq): # construct from delta encoded quantiles string - deq = deq.split(',') - num_samples = deq.count('1') - r = PerformanceTestResult(['0', 'B', str(num_samples)] + deq, - quantiles=True, delta=True) + deq = deq.split(",") + num_samples = deq.count("1") + r = PerformanceTestResult( + ["0", "B", str(num_samples)] + deq, quantiles=True, delta=True + ) self.assertEqual(r.samples.num_samples, num_samples) - self.assertEqual([s.runtime for s in r.samples.all_samples], - range(1, num_samples + 1)) + self.assertEqual( + [s.runtime for s in r.samples.all_samples], range(1, num_samples + 1) + ) delta_encoded_quantiles = """ 1,, @@ -306,55 +315,58 @@ def validatePTR(deq): # construct from delta encoded quantiles string 1,,1,1,1,1,1,1,1,1,,1,1,1,1,1,1,1,1,1, 1,,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1""" - map(validatePTR, delta_encoded_quantiles.split('\n')[1:]) + map(validatePTR, delta_encoded_quantiles.split("\n")[1:]) def test_init_meta(self): # #,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs),… # …PAGES,ICS,YIELD - log = '1,Ackermann,200,715,1281,726,47,715,7,29,15' - r = PerformanceTestResult(log.split(','), meta=True) - self.assertEqual((r.test_num, r.name), ('1', 'Ackermann')) + log = "1,Ackermann,200,715,1281,726,47,715,7,29,15" + r = PerformanceTestResult(log.split(","), meta=True) + self.assertEqual((r.test_num, r.name), ("1", "Ackermann")) self.assertEqual( (r.num_samples, r.min, r.max, r.mean, r.sd, r.median), - (200, 715, 1281, 726, 47, 715)) - self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), - (7, 29, 15)) + (200, 715, 1281, 726, 47, 715), + ) + self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), (7, 29, 15)) # #,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs),MAX_RSS(B),… # …PAGES,ICS,YIELD - log = '1,Ackermann,200,715,1951,734,97,715,36864,9,50,15' - r = PerformanceTestResult(log.split(','), memory=True, meta=True) + log = "1,Ackermann,200,715,1951,734,97,715,36864,9,50,15" + r = PerformanceTestResult(log.split(","), memory=True, meta=True) self.assertEqual( (r.num_samples, r.min, r.max, r.mean, r.sd, r.median), - (200, 715, 1951, 734, 97, 715)) + (200, 715, 1951, 734, 97, 715), + ) self.assertEqual( (r.mem_pages, r.involuntary_cs, r.yield_count, r.max_rss), - (9, 50, 15, 36864)) + (9, 50, 15, 36864), + ) # #,TEST,SAMPLES,MIN(μs),MAX(μs),PAGES,ICS,YIELD - log = '1,Ackermann,200,715,3548,8,31,15' - r = PerformanceTestResult(log.split(','), quantiles=True, meta=True) + log = "1,Ackermann,200,715,3548,8,31,15" + r = PerformanceTestResult(log.split(","), quantiles=True, meta=True) self.assertEqual((r.num_samples, r.min, r.max), (200, 715, 3548)) - self.assertEqual((r.samples.count, r.samples.min, r.samples.max), - (2, 715, 3548)) - self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), - (8, 31, 15)) + self.assertEqual( + (r.samples.count, r.samples.min, r.samples.max), (2, 715, 3548) + ) + self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), (8, 31, 15)) # #,TEST,SAMPLES,MIN(μs),MAX(μs),MAX_RSS(B),PAGES,ICS,YIELD - log = '1,Ackermann,200,715,1259,32768,8,28,15' + log = "1,Ackermann,200,715,1259,32768,8,28,15" r = PerformanceTestResult( - log.split(','), quantiles=True, memory=True, meta=True) + log.split(","), quantiles=True, memory=True, meta=True + ) self.assertEqual((r.num_samples, r.min, r.max), (200, 715, 1259)) - self.assertEqual((r.samples.count, r.samples.min, r.samples.max), - (2, 715, 1259)) + self.assertEqual( + (r.samples.count, r.samples.min, r.samples.max), (2, 715, 1259) + ) self.assertEquals(r.max_rss, 32768) - self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), - (8, 28, 15)) + self.assertEqual((r.mem_pages, r.involuntary_cs, r.yield_count), (8, 28, 15)) def test_repr(self): - log_line = '1,AngryPhonebook,20,10664,12933,11035,576,10884' - r = PerformanceTestResult(log_line.split(',')) + log_line = "1,AngryPhonebook,20,10664,12933,11035,576,10884" + r = PerformanceTestResult(log_line.split(",")) self.assertEqual( str(r), - '' + "", ) def test_merge(self): @@ -362,51 +374,70 @@ def test_merge(self): 1,AngryPhonebook,1,12045,12045,12045,0,12045 1,AngryPhonebook,1,12325,12325,12325,0,12325,10510336 1,AngryPhonebook,1,11616,11616,11616,0,11616,10502144 -1,AngryPhonebook,1,12270,12270,12270,0,12270,10498048""".split('\n')[1:] - results = map(PerformanceTestResult, - [line.split(',') for line in tests]) +1,AngryPhonebook,1,12270,12270,12270,0,12270,10498048""".split( + "\n" + )[ + 1: + ] + results = map(PerformanceTestResult, [line.split(",") for line in tests]) results[2].setup = 9 results[3].setup = 7 def as_tuple(r): - return (r.num_samples, r.min, r.max, round(r.mean, 2), - r.sd, r.median, r.max_rss, r.setup) + return ( + r.num_samples, + r.min, + r.max, + round(r.mean, 2), + r.sd, + r.median, + r.max_rss, + r.setup, + ) r = results[0] - self.assertEqual(as_tuple(r), - (1, 12045, 12045, 12045, 0, 12045, None, None)) + self.assertEqual(as_tuple(r), (1, 12045, 12045, 12045, 0, 12045, None, None)) r.merge(results[1]) - self.assertEqual(as_tuple(r), # drops SD and median, +max_rss - (2, 12045, 12325, 12185, None, None, 10510336, None)) + self.assertEqual( + as_tuple(r), # drops SD and median, +max_rss + (2, 12045, 12325, 12185, None, None, 10510336, None), + ) r.merge(results[2]) - self.assertEqual(as_tuple(r), # picks smaller of the MAX_RSS, +setup - (3, 11616, 12325, 11995.33, None, None, 10502144, 9)) + self.assertEqual( + as_tuple(r), # picks smaller of the MAX_RSS, +setup + (3, 11616, 12325, 11995.33, None, None, 10502144, 9), + ) r.merge(results[3]) - self.assertEqual(as_tuple(r), # picks smaller of the setup values - (4, 11616, 12325, 12064, None, None, 10498048, 7)) + self.assertEqual( + as_tuple(r), # picks smaller of the setup values + (4, 11616, 12325, 12064, None, None, 10498048, 7), + ) class TestResultComparison(unittest.TestCase): def setUp(self): self.r0 = PerformanceTestResult( - '101,GlobalClass,20,0,0,0,0,0,10185728'.split(',')) + "101,GlobalClass,20,0,0,0,0,0,10185728".split(",") + ) self.r01 = PerformanceTestResult( - '101,GlobalClass,20,20,20,20,0,0,10185728'.split(',')) + "101,GlobalClass,20,20,20,20,0,0,10185728".split(",") + ) self.r1 = PerformanceTestResult( - '1,AngryPhonebook,1,12325,12325,12325,0,12325,10510336'.split(',')) + "1,AngryPhonebook,1,12325,12325,12325,0,12325,10510336".split(",") + ) self.r2 = PerformanceTestResult( - '1,AngryPhonebook,1,11616,11616,11616,0,11616,10502144'.split(',')) + "1,AngryPhonebook,1,11616,11616,11616,0,11616,10502144".split(",") + ) def test_init(self): rc = ResultComparison(self.r1, self.r2) - self.assertEqual(rc.name, 'AngryPhonebook') + self.assertEqual(rc.name, "AngryPhonebook") self.assertAlmostEquals(rc.ratio, 12325.0 / 11616.0) - self.assertAlmostEquals(rc.delta, (((11616.0 / 12325.0) - 1) * 100), - places=3) + self.assertAlmostEquals(rc.delta, (((11616.0 / 12325.0) - 1) * 100), places=3) # handle test results that sometimes change to zero, when compiler # optimizes out the body of the incorrectly written test rc = ResultComparison(self.r0, self.r0) - self.assertEqual(rc.name, 'GlobalClass') + self.assertEqual(rc.name, "GlobalClass") self.assertAlmostEquals(rc.ratio, 1) self.assertAlmostEquals(rc.delta, 0, places=3) rc = ResultComparison(self.r0, self.r01) @@ -416,10 +447,7 @@ def test_init(self): self.assertAlmostEquals(rc.ratio, 20001) self.assertAlmostEquals(rc.delta, -99.995, places=3) # disallow comparison of different test results - self.assertRaises( - AssertionError, - ResultComparison, self.r0, self.r1 - ) + self.assertRaises(AssertionError, ResultComparison, self.r0, self.r1) def test_values_is_dubious(self): self.assertFalse(ResultComparison(self.r1, self.r2).is_dubious) @@ -441,7 +469,7 @@ def tearDown(self): def write_temp_file(self, file_name, data): temp_file_name = os.path.join(self.test_dir, file_name) - with open(temp_file_name, 'w') as f: + with open(temp_file_name, "w") as f: f.write(data) return temp_file_name @@ -461,19 +489,25 @@ class OldAndNewLog(unittest.TestCase): 3,Array2D,20,335831,400221,346622,0,346622 1,AngryPhonebook,20,10458,12714,11000,0,11000""" - old_results = dict([(r.name, r) - for r in - map(PerformanceTestResult, - [line.split(',') - for line in - old_log_content.splitlines()])]) - - new_results = dict([(r.name, r) - for r in - map(PerformanceTestResult, - [line.split(',') - for line in - new_log_content.splitlines()])]) + old_results = dict( + [ + (r.name, r) + for r in map( + PerformanceTestResult, + [line.split(",") for line in old_log_content.splitlines()], + ) + ] + ) + + new_results = dict( + [ + (r.name, r) + for r in map( + PerformanceTestResult, + [line.split(",") for line in new_log_content.splitlines()], + ) + ] + ) def assert_report_contains(self, texts, report): assert not isinstance(texts, str) @@ -494,95 +528,108 @@ def test_parse_results_csv(self): parser = LogParser() results = parser.parse_results(log.splitlines()) self.assertTrue(isinstance(results[0], PerformanceTestResult)) - self.assertEquals(results[0].name, 'Array.append.Array.Int?') - self.assertEquals(results[1].name, - 'Bridging.NSArray.as!.Array.NSString') - self.assertEquals(results[2].name, - 'Flatten.Array.Tuple4.lazy.for-in.Reserve') + self.assertEquals(results[0].name, "Array.append.Array.Int?") + self.assertEquals(results[1].name, "Bridging.NSArray.as!.Array.NSString") + self.assertEquals(results[2].name, "Flatten.Array.Tuple4.lazy.for-in.Reserve") def test_parse_results_tab_delimited(self): - log = '34\tBitCount\t20\t3\t4\t4\t0\t4' + log = "34\tBitCount\t20\t3\t4\t4\t0\t4" parser = LogParser() results = parser.parse_results(log.splitlines()) self.assertTrue(isinstance(results[0], PerformanceTestResult)) - self.assertEqual(results[0].name, 'BitCount') + self.assertEqual(results[0].name, "BitCount") def test_parse_results_formatted_text(self): """Parse format that Benchmark_Driver prints to console""" - log = (""" + log = """ # TEST SAMPLES MIN(μs) MAX(μs) MEAN(μs) SD(μs) MEDIAN(μs) MAX_RSS(B) 3 Array2D 20 2060 2188 2099 0 2099 20915200 Total performance tests executed: 1 -""") +""" parser = LogParser() results = parser.parse_results(log.splitlines()[1:]) # without 1st \n self.assertTrue(isinstance(results[0], PerformanceTestResult)) r = results[0] - self.assertEqual(r.name, 'Array2D') + self.assertEqual(r.name, "Array2D") self.assertEqual(r.max_rss, 20915200) def test_parse_quantiles(self): """Gathers samples from reported quantiles. Handles optional memory.""" r = LogParser.results_from_string( """#,TEST,SAMPLES,MIN(μs),MEDIAN(μs),MAX(μs) -1,Ackermann,3,54383,54512,54601""")['Ackermann'] - self.assertEqual([s.runtime for s in r.samples.all_samples], - [54383, 54512, 54601]) +1,Ackermann,3,54383,54512,54601""" + )["Ackermann"] + self.assertEqual( + [s.runtime for s in r.samples.all_samples], [54383, 54512, 54601] + ) r = LogParser.results_from_string( """#,TEST,SAMPLES,MIN(μs),MEDIAN(μs),MAX(μs),MAX_RSS(B) -1,Ackermann,3,54529,54760,55807,266240""")['Ackermann'] - self.assertEqual([s.runtime for s in r.samples.all_samples], - [54529, 54760, 55807]) +1,Ackermann,3,54529,54760,55807,266240""" + )["Ackermann"] + self.assertEqual( + [s.runtime for s in r.samples.all_samples], [54529, 54760, 55807] + ) self.assertEqual(r.max_rss, 266240) def test_parse_delta_quantiles(self): r = LogParser.results_from_string( # 2-quantile aka. median - '#,TEST,SAMPLES,MIN(μs),𝚫MEDIAN,𝚫MAX\n0,B,1,101,,')['B'] + "#,TEST,SAMPLES,MIN(μs),𝚫MEDIAN,𝚫MAX\n0,B,1,101,," + )["B"] self.assertEqual( (r.num_samples, r.min, r.median, r.max, r.samples.count), - (1, 101, 101, 101, 1)) + (1, 101, 101, 101, 1), + ) r = LogParser.results_from_string( - '#,TEST,SAMPLES,MIN(μs),𝚫MEDIAN,𝚫MAX\n0,B,2,101,,1')['B'] + "#,TEST,SAMPLES,MIN(μs),𝚫MEDIAN,𝚫MAX\n0,B,2,101,,1" + )["B"] self.assertEqual( (r.num_samples, r.min, r.median, r.max, r.samples.count), - (2, 101, 101, 102, 2)) + (2, 101, 101, 102, 2), + ) r = LogParser.results_from_string( # 20-quantiles aka. ventiles - '#,TEST,SAMPLES,MIN(μs),𝚫V1,𝚫V2,𝚫V3,𝚫V4,𝚫V5,𝚫V6,𝚫V7,𝚫V8,' + - '𝚫V9,𝚫VA,𝚫VB,𝚫VC,𝚫VD,𝚫VE,𝚫VF,𝚫VG,𝚫VH,𝚫VI,𝚫VJ,𝚫MAX\n' + - '202,DropWhileArray,200,214,,,,,,,,,,,,1,,,,,,2,16,464' - )['DropWhileArray'] + "#,TEST,SAMPLES,MIN(μs),𝚫V1,𝚫V2,𝚫V3,𝚫V4,𝚫V5,𝚫V6,𝚫V7,𝚫V8," + + "𝚫V9,𝚫VA,𝚫VB,𝚫VC,𝚫VD,𝚫VE,𝚫VF,𝚫VG,𝚫VH,𝚫VI,𝚫VJ,𝚫MAX\n" + + "202,DropWhileArray,200,214,,,,,,,,,,,,1,,,,,,2,16,464" + )["DropWhileArray"] self.assertEqual( (r.num_samples, r.min, r.max, r.samples.count), # last 3 ventiles were outliers and were excluded from the sample - (200, 214, 215, 18)) + (200, 214, 215, 18), + ) def test_parse_meta(self): r = LogParser.results_from_string( - '#,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs),' + - 'PAGES,ICS,YIELD\n' + - '0,B,1,2,2,2,0,2,7,29,15')['B'] + "#,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs)," + + "PAGES,ICS,YIELD\n" + + "0,B,1,2,2,2,0,2,7,29,15" + )["B"] self.assertEqual( - (r.min, r.mem_pages, r.involuntary_cs, r.yield_count), - (2, 7, 29, 15)) + (r.min, r.mem_pages, r.involuntary_cs, r.yield_count), (2, 7, 29, 15) + ) r = LogParser.results_from_string( - '#,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs),' + - 'MAX_RSS(B),PAGES,ICS,YIELD\n' + - '0,B,1,3,3,3,0,3,36864,9,50,15')['B'] + "#,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs)," + + "MAX_RSS(B),PAGES,ICS,YIELD\n" + + "0,B,1,3,3,3,0,3,36864,9,50,15" + )["B"] self.assertEqual( (r.min, r.mem_pages, r.involuntary_cs, r.yield_count, r.max_rss), - (3, 9, 50, 15, 36864)) + (3, 9, 50, 15, 36864), + ) r = LogParser.results_from_string( - '#,TEST,SAMPLES,MIN(μs),MAX(μs),PAGES,ICS,YIELD\n' + - '0,B,1,4,4,8,31,15')['B'] - self.assertEqual((r.min, r.mem_pages, r.involuntary_cs, r.yield_count), - (4, 8, 31, 15)) + "#,TEST,SAMPLES,MIN(μs),MAX(μs),PAGES,ICS,YIELD\n" + "0,B,1,4,4,8,31,15" + )["B"] + self.assertEqual( + (r.min, r.mem_pages, r.involuntary_cs, r.yield_count), (4, 8, 31, 15) + ) r = LogParser.results_from_string( - '#,TEST,SAMPLES,MIN(μs),MAX(μs),MAX_RSS(B),PAGES,ICS,YIELD\n' + - '0,B,1,5,5,32768,8,28,15')['B'] + "#,TEST,SAMPLES,MIN(μs),MAX(μs),MAX_RSS(B),PAGES,ICS,YIELD\n" + + "0,B,1,5,5,32768,8,28,15" + )["B"] self.assertEqual( (r.min, r.mem_pages, r.involuntary_cs, r.yield_count, r.max_rss), - (5, 8, 28, 15, 32768)) + (5, 8, 28, 15, 32768), + ) def test_parse_results_verbose(self): """Parse multiple performance test results with 2 sample formats: @@ -608,27 +655,31 @@ def test_parse_results_verbose(self): Totals,2""" parser = LogParser() - results = parser.parse_results(verbose_log.split('\n')) + results = parser.parse_results(verbose_log.split("\n")) r = results[0] self.assertEqual( (r.name, r.min, r.max, int(r.mean), int(r.sd), r.median), - ('AngryPhonebook', 11467, 13898, 12392, 1315, 11812) + ("AngryPhonebook", 11467, 13898, 12392, 1315, 11812), ) self.assertEqual(r.num_samples, r.samples.num_samples) - self.assertEqual(results[0].samples.all_samples, - [(0, 78, 11812), (1, 90, 13898), (2, 90, 11467)]) + self.assertEqual( + results[0].samples.all_samples, + [(0, 78, 11812), (1, 90, 13898), (2, 90, 11467)], + ) self.assertEqual(r.yields, None) r = results[1] self.assertEqual( (r.name, r.min, r.max, int(r.mean), int(r.sd), r.median), - ('Array2D', 369900, 381039, 373994, 6127, 371043) + ("Array2D", 369900, 381039, 373994, 6127, 371043), ) self.assertEqual(r.setup, 14444) self.assertEqual(r.num_samples, r.samples.num_samples) - self.assertEqual(results[1].samples.all_samples, - [(0, 1, 369900), (1, 1, 381039), (2, 1, 371043)]) + self.assertEqual( + results[1].samples.all_samples, + [(0, 1, 369900), (1, 1, 381039), (2, 1, 371043)], + ) yielded = r.yields[0] self.assertEqual(yielded.before_sample, 1) self.assertEqual(yielded.after, 369918) @@ -642,7 +693,7 @@ def test_parse_environment_verbose(self): 2,AngryPhonebook,3,11269,11884,11657,338,11820 """ parser = LogParser() - results = parser.parse_results(verbose_log.split('\n')) + results = parser.parse_results(verbose_log.split("\n")) r = results[0] self.assertEqual(r.max_rss, 32768) @@ -655,8 +706,8 @@ def test_results_from_merge(self): concatenated_logs = """4,ArrayAppend,20,23641,29000,24990,0,24990 4,ArrayAppend,1,20000,20000,20000,0,20000""" results = LogParser.results_from_string(concatenated_logs) - self.assertEqual(results.keys(), ['ArrayAppend']) - result = results['ArrayAppend'] + self.assertEqual(results.keys(), ["ArrayAppend"]) + result = results["ArrayAppend"] self.assertTrue(isinstance(result, PerformanceTestResult)) self.assertEqual(result.min, 20000) self.assertEqual(result.max, 29000) @@ -677,8 +728,8 @@ def test_results_from_merge_verbose(self): Sample 3,364245 3,Array2D,4,363094,376131,368159,5931,369169""" results = LogParser.results_from_string(concatenated_logs) - self.assertEqual(results.keys(), ['Array2D']) - result = results['Array2D'] + self.assertEqual(results.keys(), ["Array2D"]) + result = results["Array2D"] self.assertTrue(isinstance(result, PerformanceTestResult)) self.assertEqual(result.min, 350815) self.assertEqual(result.max, 376131) @@ -715,7 +766,7 @@ def test_excludes_outliers_from_samples(self): 65,DropFirstAnySeqCntRangeLazy,10,184,455,228,79,206 """ parser = LogParser() - result = parser.parse_results(verbose_log.split('\n'))[0] + result = parser.parse_results(verbose_log.split("\n"))[0] self.assertEqual(result.num_samples, 10) self.assertEqual(result.samples.count, 8) self.assertEqual(len(result.samples.outliers), 2) @@ -727,26 +778,26 @@ def names(tests): return [t.name for t in tests] tc = TestComparator(self.old_results, self.new_results, 0.05) - self.assertEqual(names(tc.unchanged), ['AngryPhonebook', 'Array2D']) - self.assertEqual(names(tc.increased), ['ByteSwap', 'ArrayAppend']) - self.assertEqual(names(tc.decreased), ['BitCount']) - self.assertEqual(names(tc.added), ['TwoSum']) - self.assertEqual(names(tc.removed), ['AnyHashableWithAClass']) + self.assertEqual(names(tc.unchanged), ["AngryPhonebook", "Array2D"]) + self.assertEqual(names(tc.increased), ["ByteSwap", "ArrayAppend"]) + self.assertEqual(names(tc.decreased), ["BitCount"]) + self.assertEqual(names(tc.added), ["TwoSum"]) + self.assertEqual(names(tc.removed), ["AnyHashableWithAClass"]) # other way around tc = TestComparator(self.new_results, self.old_results, 0.05) - self.assertEqual(names(tc.unchanged), ['AngryPhonebook', 'Array2D']) - self.assertEqual(names(tc.increased), ['BitCount']) - self.assertEqual(names(tc.decreased), ['ByteSwap', 'ArrayAppend']) - self.assertEqual(names(tc.added), ['AnyHashableWithAClass']) - self.assertEqual(names(tc.removed), ['TwoSum']) + self.assertEqual(names(tc.unchanged), ["AngryPhonebook", "Array2D"]) + self.assertEqual(names(tc.increased), ["BitCount"]) + self.assertEqual(names(tc.decreased), ["ByteSwap", "ArrayAppend"]) + self.assertEqual(names(tc.added), ["AnyHashableWithAClass"]) + self.assertEqual(names(tc.removed), ["TwoSum"]) # delta_threshold determines the sorting into change groups; # report only change above 100% (ByteSwap's runtime went to 0): tc = TestComparator(self.old_results, self.new_results, 1) self.assertEqual( names(tc.unchanged), - ['AngryPhonebook', 'Array2D', 'ArrayAppend', 'BitCount'] + ["AngryPhonebook", "Array2D", "ArrayAppend", "BitCount"], ) - self.assertEqual(names(tc.increased), ['ByteSwap']) + self.assertEqual(names(tc.increased), ["ByteSwap"]) self.assertEqual(tc.decreased, []) @@ -770,45 +821,58 @@ def assert_html_contains(self, texts): def test_values(self): self.assertEqual( - ReportFormatter.values(PerformanceTestResult( - '1,AngryPhonebook,20,10664,12933,11035,576,10884'.split(','))), - ('AngryPhonebook', '10664', '12933', '11035', '—') + ReportFormatter.values( + PerformanceTestResult( + "1,AngryPhonebook,20,10664,12933,11035,576,10884".split(",") + ) + ), + ("AngryPhonebook", "10664", "12933", "11035", "—"), ) self.assertEqual( - ReportFormatter.values(PerformanceTestResult( - '1,AngryPhonebook,1,12045,12045,12045,0,12045,10510336' - .split(','))), - ('AngryPhonebook', '12045', '12045', '12045', '10510336') + ReportFormatter.values( + PerformanceTestResult( + "1,AngryPhonebook,1,12045,12045,12045,0,12045,10510336".split(",") + ) + ), + ("AngryPhonebook", "12045", "12045", "12045", "10510336"), ) r1 = PerformanceTestResult( - '1,AngryPhonebook,1,12325,12325,12325,0,12325,10510336'.split(',')) + "1,AngryPhonebook,1,12325,12325,12325,0,12325,10510336".split(",") + ) r2 = PerformanceTestResult( - '1,AngryPhonebook,1,11616,11616,11616,0,11616,10502144'.split(',')) + "1,AngryPhonebook,1,11616,11616,11616,0,11616,10502144".split(",") + ) self.assertEqual( ReportFormatter.values(ResultComparison(r1, r2)), - ('AngryPhonebook', '12325', '11616', '-5.8%', '1.06x') + ("AngryPhonebook", "12325", "11616", "-5.8%", "1.06x"), ) self.assertEqual( ReportFormatter.values(ResultComparison(r2, r1)), - ('AngryPhonebook', '11616', '12325', '+6.1%', '0.94x') + ("AngryPhonebook", "11616", "12325", "+6.1%", "0.94x"), ) r2.max = r1.min + 1 self.assertEqual( ReportFormatter.values(ResultComparison(r1, r2))[4], - '1.06x (?)' # is_dubious + "1.06x (?)", # is_dubious ) def test_justified_columns(self): """Table columns are all formated with same width, defined by the longest value. """ - self.assert_markdown_contains([ - 'AnyHashableWithAClass | 247027 | 319065 | 259056 | 10250445', - 'Array2D | 335831 | 335831 | +0.0% | 1.00x']) - self.assert_git_contains([ - 'AnyHashableWithAClass 247027 319065 259056 10250445', - 'Array2D 335831 335831 +0.0% 1.00x']) + self.assert_markdown_contains( + [ + "AnyHashableWithAClass | 247027 | 319065 | 259056 | 10250445", + "Array2D | 335831 | 335831 | +0.0% | 1.00x", + ] + ) + self.assert_git_contains( + [ + "AnyHashableWithAClass 247027 319065 259056 10250445", + "Array2D 335831 335831 +0.0% 1.00x", + ] + ) def test_column_headers(self): """Report contains table headers for ResultComparisons and changed @@ -817,49 +881,63 @@ def test_column_headers(self): performance_test_result = self.tc.added[0] self.assertEqual( ReportFormatter.header_for(performance_test_result), - ('TEST', 'MIN', 'MAX', 'MEAN', 'MAX_RSS') + ("TEST", "MIN", "MAX", "MEAN", "MAX_RSS"), ) comparison_result = self.tc.increased[0] self.assertEqual( ReportFormatter.header_for(comparison_result), - ('TEST', 'OLD', 'NEW', 'DELTA', 'RATIO') - ) - self.assert_markdown_contains([ - 'TEST | OLD | NEW | DELTA | RATIO', - ':--- | ---: | ---: | ---: | ---: ', - 'TEST | MIN | MAX | MEAN | MAX_RSS']) - self.assert_git_contains([ - 'TEST OLD NEW DELTA RATIO', - 'TEST MIN MAX MEAN MAX_RSS']) - self.assert_html_contains([ - """ + ("TEST", "OLD", "NEW", "DELTA", "RATIO"), + ) + self.assert_markdown_contains( + [ + "TEST | OLD | NEW | DELTA | RATIO", + ":--- | ---: | ---: | ---: | ---: ", + "TEST | MIN | MAX | MEAN | MAX_RSS", + ] + ) + self.assert_git_contains( + [ + "TEST OLD NEW DELTA RATIO", + "TEST MIN MAX MEAN MAX_RSS", + ] + ) + self.assert_html_contains( + [ + """ OLD NEW DELTA RATIO""", - """ + """ MIN MAX MEAN - MAX_RSS"""]) + MAX_RSS""", + ] + ) def test_emphasize_speedup(self): """Emphasize speedup values for regressions and improvements""" # tests in No Changes don't have emphasized speedup - self.assert_markdown_contains([ - 'BitCount | 3 | 9 | +199.9% | **0.33x**', - 'ByteSwap | 4 | 0 | -100.0% | **4001.00x**', - 'AngryPhonebook | 10458 | 10458 | +0.0% | 1.00x ', - 'ArrayAppend | 23641 | 20000 | -15.4% | **1.18x (?)**' - ]) - self.assert_git_contains([ - 'BitCount 3 9 +199.9% **0.33x**', - 'ByteSwap 4 0 -100.0% **4001.00x**', - 'AngryPhonebook 10458 10458 +0.0% 1.00x', - 'ArrayAppend 23641 20000 -15.4% **1.18x (?)**' - ]) - self.assert_html_contains([ - """ + self.assert_markdown_contains( + [ + "BitCount | 3 | 9 | +199.9% | **0.33x**", + "ByteSwap | 4 | 0 | -100.0% | **4001.00x**", + "AngryPhonebook | 10458 | 10458 | +0.0% | 1.00x ", + "ArrayAppend | 23641 | 20000 | -15.4% | **1.18x (?)**", + ] + ) + self.assert_git_contains( + [ + "BitCount 3 9 +199.9% **0.33x**", + "ByteSwap 4 0 -100.0% **4001.00x**", + "AngryPhonebook 10458 10458 +0.0% 1.00x", + "ArrayAppend 23641 20000 -15.4% **1.18x (?)**", + ] + ) + self.assert_html_contains( + [ + """ BitCount 3 @@ -867,7 +945,7 @@ def test_emphasize_speedup(self): +199.9% 0.33x """, - """ + """ ByteSwap 4 @@ -875,182 +953,221 @@ def test_emphasize_speedup(self): -100.0% 4001.00x """, - """ + """ AngryPhonebook 10458 10458 +0.0% 1.00x - """ - ]) + """, + ] + ) def test_sections(self): """Report is divided into sections with summaries.""" - self.assert_markdown_contains([ - """
+ self.assert_markdown_contains( + [ + """
Regression (1)""", - """
+ """
Improvement (2)""", - """
+ """
No Changes (2)""", - """
+ """
Added (1)""", - """
- Removed (1)"""]) - self.assert_git_contains([ - 'Regression (1): \n', - 'Improvement (2): \n', - 'No Changes (2): \n', - 'Added (1): \n', - 'Removed (1): \n']) - self.assert_html_contains([ - "Regression (1)", - "Improvement (2)", - "No Changes (2)", - "Added (1)", - "Removed (1)"]) + """
+ Removed (1)""", + ] + ) + self.assert_git_contains( + [ + "Regression (1): \n", + "Improvement (2): \n", + "No Changes (2): \n", + "Added (1): \n", + "Removed (1): \n", + ] + ) + self.assert_html_contains( + [ + "Regression (1)", + "Improvement (2)", + "No Changes (2)", + "Added (1)", + "Removed (1)", + ] + ) def test_report_only_changes(self): """Leave out tests without significant change.""" rf = ReportFormatter(self.tc, changes_only=True) markdown, git, html = rf.markdown(), rf.git(), rf.html() - self.assertNotIn('No Changes', markdown) - self.assertNotIn('AngryPhonebook', markdown) - self.assertNotIn('No Changes', git) - self.assertNotIn('AngryPhonebook', git) - self.assertNotIn('No Changes', html) - self.assertNotIn('AngryPhonebook', html) + self.assertNotIn("No Changes", markdown) + self.assertNotIn("AngryPhonebook", markdown) + self.assertNotIn("No Changes", git) + self.assertNotIn("AngryPhonebook", git) + self.assertNotIn("No Changes", html) + self.assertNotIn("AngryPhonebook", html) def test_single_table_report(self): """Single table report has inline headers and no elaborate sections.""" self.tc.removed = [] # test handling empty section rf = ReportFormatter(self.tc, changes_only=True, single_table=True) markdown = rf.markdown() - self.assertNotIn('Regression (1)', - 'TEST | OLD | NEW | DELTA | RATIO', - 'BitCount | 3 | 9 | +199.9% | **0.33x**', + "Regression (1)", + "TEST | OLD | NEW | DELTA | RATIO", + "BitCount | 3 | 9 | +199.9% | **0.33x**", ] git = [ - 'Regression (1):', - 'TEST OLD NEW DELTA RATIO', - 'BitCount 3 9 +199.9% **0.33x**', + "Regression (1):", + "TEST OLD NEW DELTA RATIO", + "BitCount 3 9 +199.9% **0.33x**", ] - html = ['', "BitCount"] + html = ["", "BitCount"] def setUp(self): super(Test_compare_perf_tests_main, self).setUp() - self.old_log = self.write_temp_file('old.log', self.old_log_content) - self.new_log = self.write_temp_file('new.log', self.new_log_content) + self.old_log = self.write_temp_file("old.log", self.old_log_content) + self.new_log = self.write_temp_file("new.log", self.new_log_content) def execute_main_with_format(self, report_format, test_output=False): - report_file = self.test_dir + 'report.log' - args = ['compare_perf_tests.py', - '--old-file', self.old_log, - '--new-file', self.new_log, - '--format', report_format] - - sys.argv = (args if not test_output else - args + ['--output', report_file]) + report_file = self.test_dir + "report.log" + args = [ + "compare_perf_tests.py", + "--old-file", + self.old_log, + "--new-file", + self.new_log, + "--format", + report_format, + ] + + sys.argv = args if not test_output else args + ["--output", report_file] with captured_output() as (out, _): main() report_out = out.getvalue() if test_output: - with open(report_file, 'r') as f: + with open(report_file, "r") as f: report = f.read() # because print adds newline, add one here, too: - report_file = str(report + '\n') + report_file = str(report + "\n") else: report_file = None @@ -1058,40 +1175,41 @@ def execute_main_with_format(self, report_format, test_output=False): def test_markdown(self): """Writes Markdown formatted report to stdout""" - report_out, _ = self.execute_main_with_format('markdown') + report_out, _ = self.execute_main_with_format("markdown") self.assert_report_contains(self.markdown, report_out) def test_markdown_output(self): """Writes Markdown formatted report to stdout and `--output` file.""" - report_out, report_file = ( - self.execute_main_with_format('markdown', test_output=True)) + report_out, report_file = self.execute_main_with_format( + "markdown", test_output=True + ) self.assertEqual(report_out, report_file) self.assert_report_contains(self.markdown, report_file) def test_git(self): """Writes Git formatted report to stdout.""" - report_out, _ = self.execute_main_with_format('git') + report_out, _ = self.execute_main_with_format("git") self.assert_report_contains(self.git, report_out) def test_git_output(self): """Writes Git formatted report to stdout and `--output` file.""" - report_out, report_file = ( - self.execute_main_with_format('git', test_output=True)) + report_out, report_file = self.execute_main_with_format("git", test_output=True) self.assertEqual(report_out, report_file) self.assert_report_contains(self.git, report_file) def test_html(self): """Writes HTML formatted report to stdout.""" - report_out, _ = self.execute_main_with_format('html') + report_out, _ = self.execute_main_with_format("html") self.assert_report_contains(self.html, report_out) def test_html_output(self): """Writes HTML formatted report to stdout and `--output` file.""" - report_out, report_file = ( - self.execute_main_with_format('html', test_output=True)) + report_out, report_file = self.execute_main_with_format( + "html", test_output=True + ) self.assertEqual(report_out, report_file) self.assert_report_contains(self.html, report_file) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/benchmark/scripts/test_utils.py b/benchmark/scripts/test_utils.py index 6a2bf8856a99f..4b675d9d82582 100644 --- a/benchmark/scripts/test_utils.py +++ b/benchmark/scripts/test_utils.py @@ -78,14 +78,15 @@ def expect(self, call_args, response): def assert_called_with(self, expected_args): """Verify that the tested method was called with provided arguments.""" expected_args = tuple(expected_args) - assert expected_args in self.calls, ( - 'Expected: {0} in Called: {1}'.format(expected_args, self.calls)) + assert expected_args in self.calls, "Expected: {0} in Called: {1}".format( + expected_args, self.calls + ) def assert_called_all_expected(self): """Verify that all expeced invocations of tested method were called.""" - assert self.calls == self.expected, ( - '\nExpected: {0}, \n Called: {1}'.format( - self.expected, self.calls)) + assert self.calls == self.expected, "\nExpected: {0}, \n Called: {1}".format( + self.expected, self.calls + ) class MockLoggingHandler(logging.Handler): @@ -103,5 +104,9 @@ def emit(self, record): def reset(self): """Clear all log messages.""" self.messages = { - 'debug': [], 'info': [], 'warning': [], 'error': [], 'critical': [] + "debug": [], + "info": [], + "warning": [], + "error": [], + "critical": [], } diff --git a/benchmark/utils/convertToJSON.py b/benchmark/utils/convertToJSON.py index 54aedc7270068..b7a547116d7ba 100644 --- a/benchmark/utils/convertToJSON.py +++ b/benchmark/utils/convertToJSON.py @@ -74,9 +74,9 @@ if __name__ == "__main__": data = {} - data['Tests'] = [] - data['Machine'] = {} - data['Run'] = {} + data["Tests"] = [] + data["Machine"] = {} + data["Run"] = {} for line in sys.stdin: m = SCORERE.match(line) if not m: @@ -84,8 +84,8 @@ if not m: continue test = {} - test['Data'] = [int(m.group(VALGROUP))] - test['Info'] = {} - test['Name'] = [m.group(KEYGROUP)] - data['Tests'].append(test) + test["Data"] = [int(m.group(VALGROUP))] + test["Info"] = {} + test["Name"] = [m.group(KEYGROUP)] + data["Tests"].append(test) print(json.dumps(data, sort_keys=True, indent=4)) diff --git a/cmake/modules/SwiftXcodeSupport.cmake b/cmake/modules/SwiftXcodeSupport.cmake index ea5135629e382..0c73b12ec03d7 100644 --- a/cmake/modules/SwiftXcodeSupport.cmake +++ b/cmake/modules/SwiftXcodeSupport.cmake @@ -100,8 +100,8 @@ macro(swift_common_xcode_cxx_config) # Force usage of Clang. set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0" CACHE STRING "Xcode Compiler") - # Use C++'11. - set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11" + # Use C++'14. + set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14" CACHE STRING "Xcode C++ Language Standard") # Use libc++. set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++" diff --git a/include/swift/ABI/TrailingObjects.h b/include/swift/ABI/TrailingObjects.h index 2d09d3352fd3c..c6da24b342f2d 100644 --- a/include/swift/ABI/TrailingObjects.h +++ b/include/swift/ABI/TrailingObjects.h @@ -55,6 +55,7 @@ #ifndef SWIFT_ABI_TRAILINGOBJECTS_H #define SWIFT_ABI_TRAILINGOBJECTS_H +#include "llvm/Support/Alignment.h" #include "llvm/Support/AlignOf.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/MathExtras.h" @@ -175,7 +176,7 @@ class TrailingObjectsImpl( - llvm::alignAddr(Ptr, alignof(NextTy))); + llvm::alignAddr(Ptr, llvm::Align(alignof(NextTy)))); else return reinterpret_cast(Ptr); } @@ -189,7 +190,8 @@ class TrailingObjectsImpl()); if (requiresRealignment()) - return reinterpret_cast(llvm::alignAddr(Ptr, alignof(NextTy))); + return reinterpret_cast( + llvm::alignAddr(Ptr, llvm::Align(alignof(NextTy)))); else return reinterpret_cast(Ptr); } diff --git a/include/swift/ABI/TypeIdentity.h b/include/swift/ABI/TypeIdentity.h index 9fa0aae2b51a7..129417b3f36b6 100644 --- a/include/swift/ABI/TypeIdentity.h +++ b/include/swift/ABI/TypeIdentity.h @@ -19,6 +19,7 @@ #define SWIFT_ABI_TYPEIDENTITY_H #include "swift/Basic/LLVM.h" +#include namespace swift { template class TargetTypeContextDescriptor; diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def index c42896b356477..610c9c897fd28 100644 --- a/include/swift/AST/DiagnosticsSema.def +++ b/include/swift/AST/DiagnosticsSema.def @@ -703,6 +703,8 @@ NOTE(selector_construction_suppress_warning,none, ERROR(cannot_return_value_from_void_func,none, "unexpected non-void return value in void function", ()) +NOTE(add_return_type_note,none, + "did you mean to add a return type?", ()) //------------------------------------------------------------------------------ // MARK: Name Binding diff --git a/include/swift/AST/Evaluator.h b/include/swift/AST/Evaluator.h index 6ad636f7f4566..d91c27299ae67 100644 --- a/include/swift/AST/Evaluator.h +++ b/include/swift/AST/Evaluator.h @@ -345,7 +345,7 @@ class Evaluator { // Check for a cycle. if (checkDependency(activeReq)) { return llvm::Error( - llvm::make_unique>(request, *this)); + std::make_unique>(request, *this)); } // Make sure we remove this from the set of active requests once we're diff --git a/include/swift/AST/SimpleRequest.h b/include/swift/AST/SimpleRequest.h index cab957ec85114..018163f541630 100644 --- a/include/swift/AST/SimpleRequest.h +++ b/include/swift/AST/SimpleRequest.h @@ -195,7 +195,7 @@ class SimpleRequest { template llvm::Expected - callDerived(Evaluator &evaluator, llvm::index_sequence) const { + callDerived(Evaluator &evaluator, std::index_sequence) const { static_assert(sizeof...(Indices) > 0, "Subclass must define evaluate()"); return asDerived().evaluate(evaluator, std::get(storage)...); } @@ -217,7 +217,7 @@ class SimpleRequest { static llvm::Expected evaluateRequest(const Derived &request, Evaluator &evaluator) { return request.callDerived(evaluator, - llvm::index_sequence_for()); + std::index_sequence_for()); } /// Retrieve the nearest source location to which this request applies. diff --git a/include/swift/Basic/Statistic.h b/include/swift/Basic/Statistic.h index 0d39ca074756e..80759a78bb0a8 100644 --- a/include/swift/Basic/Statistic.h +++ b/include/swift/Basic/Statistic.h @@ -25,8 +25,7 @@ #define SWIFT_FUNC_STAT_NAMED(DEBUG_TYPE) \ do { \ - static llvm::Statistic FStat = \ - {DEBUG_TYPE, __func__, __func__, {0}, {false}}; \ + static llvm::Statistic FStat = {DEBUG_TYPE, __func__, __func__}; \ ++FStat; \ } while (0) diff --git a/include/swift/Frontend/Frontend.h b/include/swift/Frontend/Frontend.h index c2612775a77d1..4c2f6f8929899 100644 --- a/include/swift/Frontend/Frontend.h +++ b/include/swift/Frontend/Frontend.h @@ -482,7 +482,7 @@ class CompilerInstance { void createDependencyTracker(bool TrackSystemDeps) { assert(!Context && "must be called before setup()"); - DepTracker = llvm::make_unique(TrackSystemDeps); + DepTracker = std::make_unique(TrackSystemDeps); } DependencyTracker *getDependencyTracker() { return DepTracker.get(); } const DependencyTracker *getDependencyTracker() const { return DepTracker.get(); } diff --git a/include/swift/LLVMPasses/Passes.h b/include/swift/LLVMPasses/Passes.h index 4594d11fec64c..d716d3087ec78 100644 --- a/include/swift/LLVMPasses/Passes.h +++ b/include/swift/LLVMPasses/Passes.h @@ -15,6 +15,8 @@ #include "swift/LLVMPasses/PassesFwd.h" #include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/Passes.h" +#include "llvm/InitializePasses.h" #include "llvm/Pass.h" namespace swift { diff --git a/include/swift/Reflection/TypeRef.h b/include/swift/Reflection/TypeRef.h index d0c3d3249557a..a6f161825c23b 100644 --- a/include/swift/Reflection/TypeRef.h +++ b/include/swift/Reflection/TypeRef.h @@ -150,6 +150,9 @@ class alignas(void *) TypeRef { void dump() const; void dump(FILE *file, unsigned Indent = 0) const; + /// Build a demangle tree from this TypeRef. + Demangle::NodePointer getDemangling(Demangle::Demangler &Dem) const; + bool isConcrete() const; bool isConcreteAfterSubstitutions(const GenericArgumentMap &Subs) const; diff --git a/include/swift/SIL/PatternMatch.h b/include/swift/SIL/PatternMatch.h index 8d451f9e73db8..7b3a83bee1c0d 100644 --- a/include/swift/SIL/PatternMatch.h +++ b/include/swift/SIL/PatternMatch.h @@ -310,7 +310,7 @@ namespace detail { struct GetOperandsFunctor { template std::array - operator()(SILInstruction *i, llvm::index_sequence seq) const { + operator()(SILInstruction *i, std::index_sequence seq) const { return {i->getOperand(Idx)...}; } }; @@ -327,15 +327,15 @@ template struct MatcherFunctor { template std::array matchHelper(const std::array &operands, - llvm::index_sequence seq) { + std::index_sequence seq) { return {individual(std::get(matchers), std::get(operands))...}; } bool match(SILInstruction *i) { std::array operands = - GetOperandsFunctor{}(i, llvm::index_sequence_for{}); + GetOperandsFunctor{}(i, std::index_sequence_for{}); auto tmpResult = - matchHelper(operands, llvm::index_sequence_for{}); + matchHelper(operands, std::index_sequence_for{}); for (unsigned i : indices(tmpResult)) { if (!tmpResult[i]) return false; diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h index ec22b11ea77c6..33a03dd726737 100644 --- a/include/swift/SIL/SILInstruction.h +++ b/include/swift/SIL/SILInstruction.h @@ -999,7 +999,7 @@ class MultipleValueInstructionTrailingObjects { - static_assert(LLVM_IS_FINAL(DerivedResult), + static_assert(std::is_final(), "Expected DerivedResult to be final"); static_assert( std::is_base_of::value, diff --git a/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h b/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h index 8b5e509411936..eb4f5775912e5 100644 --- a/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h @@ -172,7 +172,7 @@ class BasicCalleeAnalysis : public SILAnalysis { void updateCache() { if (!Cache) - Cache = llvm::make_unique(M); + Cache = std::make_unique(M); } CalleeList getCalleeList(FullApplySite FAS) { diff --git a/include/swift/SILOptimizer/Analysis/DominanceAnalysis.h b/include/swift/SILOptimizer/Analysis/DominanceAnalysis.h index dc761890264e4..40e1f6e419ec3 100644 --- a/include/swift/SILOptimizer/Analysis/DominanceAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/DominanceAnalysis.h @@ -42,7 +42,7 @@ class DominanceAnalysis : public FunctionAnalysisBase { } std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(F); + return std::make_unique(F); } virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override { @@ -72,7 +72,7 @@ class PostDominanceAnalysis : public FunctionAnalysisBase { std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(F); + return std::make_unique(F); } virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override { diff --git a/include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h b/include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h index 329a71cb218d5..6174485c7f181 100644 --- a/include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h @@ -302,7 +302,7 @@ class EpilogueARCAnalysis : public FunctionAnalysisBase virtual std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(F, PO, AA, RC); + return std::make_unique(F, PO, AA, RC); } virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override { diff --git a/include/swift/SILOptimizer/Analysis/IVAnalysis.h b/include/swift/SILOptimizer/Analysis/IVAnalysis.h index 45a35a1f7bf47..4fb381790227f 100644 --- a/include/swift/SILOptimizer/Analysis/IVAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/IVAnalysis.h @@ -91,7 +91,7 @@ class IVAnalysis final : public FunctionAnalysisBase { } std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(*F); + return std::make_unique(*F); } /// For now we always invalidate. diff --git a/include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h b/include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h index 985b9cb362c27..285e694723617 100644 --- a/include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h @@ -1082,7 +1082,7 @@ class LoopRegionAnalysis : public FunctionAnalysisBase { virtual std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(F, POA->get(F), + return std::make_unique(F, POA->get(F), SLA->get(F)); } diff --git a/include/swift/SILOptimizer/Analysis/PostOrderAnalysis.h b/include/swift/SILOptimizer/Analysis/PostOrderAnalysis.h index f131988c6e2f5..e8dfea7ea206c 100644 --- a/include/swift/SILOptimizer/Analysis/PostOrderAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/PostOrderAnalysis.h @@ -36,7 +36,7 @@ class PostOrderAnalysis : public FunctionAnalysisBase { protected: virtual std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(F); + return std::make_unique(F); } virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override { diff --git a/include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h b/include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h index abb5093a8dc27..f4ddc2ee77673 100644 --- a/include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h +++ b/include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h @@ -120,7 +120,7 @@ class RCIdentityAnalysis : public FunctionAnalysisBase { virtual std::unique_ptr newFunctionAnalysis(SILFunction *F) override { - return llvm::make_unique(DA); + return std::make_unique(DA); } virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override { diff --git a/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h b/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h index 6a6e221e960e0..e6933b2660706 100644 --- a/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h +++ b/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h @@ -20,6 +20,7 @@ #include "swift/SILOptimizer/Utils/ConstantFolding.h" #include "swift/SILOptimizer/Utils/SILInliner.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/Support/CommandLine.h" using namespace swift; diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 0743cc7c8b29c..25f83f4ab5719 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -504,7 +504,8 @@ static ModuleDecl *createBuiltinModule(ASTContext &ctx) { inline ASTContext::Implementation &ASTContext::getImpl() const { auto pointer = reinterpret_cast(const_cast(this)); - auto offset = llvm::alignAddr((void*)sizeof(*this), alignof(Implementation)); + auto offset = llvm::alignAddr((void *)sizeof(*this), + llvm::Align(alignof(Implementation))); return *reinterpret_cast(pointer + offset); } @@ -524,7 +525,8 @@ ASTContext *ASTContext::get(LangOptions &langOpts, auto size = llvm::alignTo(sizeof(ASTContext) + sizeof(Implementation), align); auto mem = AlignedAlloc(size, align); auto impl = reinterpret_cast((char*)mem + sizeof(ASTContext)); - impl = reinterpret_cast(llvm::alignAddr(impl,alignof(Implementation))); + impl = reinterpret_cast( + llvm::alignAddr(impl, llvm::Align(alignof(Implementation)))); new (impl) Implementation(); return new (mem) ASTContext(langOpts, typeckOpts, SearchPathOpts, SourceMgr, Diags); @@ -1547,7 +1549,7 @@ void ASTContext::registerGenericSignatureBuilder( ++NumRegisteredGenericSignatureBuilders; genericSignatureBuilders[canSig] = - llvm::make_unique(std::move(builder)); + std::make_unique(std::move(builder)); } GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder( diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp index 262f0222dcb77..c3f85c992b6d9 100644 --- a/lib/AST/Builtins.cpp +++ b/lib/AST/Builtins.cpp @@ -1381,10 +1381,14 @@ Type IntrinsicTypeDecoder::decodeImmediate() { case IITDescriptor::ExtendArgument: case IITDescriptor::TruncArgument: case IITDescriptor::HalfVecArgument: + case IITDescriptor::ScalableVecArgument: case IITDescriptor::VarArg: case IITDescriptor::Token: case IITDescriptor::VecElementArgument: case IITDescriptor::VecOfAnyPtrsToElt: + case IITDescriptor::VecOfBitcastsToInt: + case IITDescriptor::Subdivide2Argument: + case IITDescriptor::Subdivide4Argument: // These types cannot be expressed in swift yet. return Type(); diff --git a/lib/AST/ClangTypeConverter.cpp b/lib/AST/ClangTypeConverter.cpp index 14b9aec5f289f..aa141e1454ea9 100644 --- a/lib/AST/ClangTypeConverter.cpp +++ b/lib/AST/ClangTypeConverter.cpp @@ -369,7 +369,7 @@ clang::QualType ClangTypeConverter::visitTupleType(TupleType *type) { return clang::QualType(); APInt size(32, tupleNumElements); - return ClangASTContext.getConstantArrayType(clangEltTy, size, + return ClangASTContext.getConstantArrayType(clangEltTy, size, nullptr, clang::ArrayType::Normal, 0); } diff --git a/lib/AST/DiagnosticConsumer.cpp b/lib/AST/DiagnosticConsumer.cpp index fe647177745ef..0ef2551055e2c 100644 --- a/lib/AST/DiagnosticConsumer.cpp +++ b/lib/AST/DiagnosticConsumer.cpp @@ -71,7 +71,7 @@ FileSpecificDiagnosticConsumer::consolidateSubconsumers( if (subconsumers.size() == 1) return std::move(subconsumers.front()).consumer; // Cannot use return - // llvm::make_unique(subconsumers); because + // std::make_unique(subconsumers); because // the constructor is private. return std::unique_ptr( new FileSpecificDiagnosticConsumer(subconsumers)); diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 4b2406099ebfb..b999a9d1eece9 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -813,13 +813,14 @@ APInt BuiltinIntegerWidth::parse(StringRef text, unsigned radix, bool negate, static APFloat getFloatLiteralValue(bool IsNegative, StringRef Text, const llvm::fltSemantics &Semantics) { APFloat Val(Semantics); - APFloat::opStatus Res = - Val.convertFromString(Text, llvm::APFloat::rmNearestTiesToEven); - assert(Res != APFloat::opInvalidOp && "Sema didn't reject invalid number"); - (void)Res; + llvm::Expected MaybeRes = + Val.convertFromString(Text, llvm::APFloat::rmNearestTiesToEven); + assert(MaybeRes && *MaybeRes != APFloat::opInvalidOp && + "Sema didn't reject invalid number"); + (void)MaybeRes; if (IsNegative) { auto NegVal = APFloat::getZero(Semantics, /*negative*/ true); - Res = NegVal.subtract(Val, llvm::APFloat::rmNearestTiesToEven); + auto Res = NegVal.subtract(Val, llvm::APFloat::rmNearestTiesToEven); assert(Res != APFloat::opInvalidOp && "Sema didn't reject invalid number"); (void)Res; return NegVal; diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp index bb58412049496..6269dab50a461 100644 --- a/lib/AST/GenericSignatureBuilder.cpp +++ b/lib/AST/GenericSignatureBuilder.cpp @@ -3208,7 +3208,7 @@ GenericSignatureBuilder::Implementation::getOrCreateRewriteTreeRoot( return root; auto &root = RewriteTreeRoots[anchor]; - root = llvm::make_unique(nullptr); + root = std::make_unique(nullptr); return root.get(); } diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp index a478cb81a4514..b08b2de0ab806 100644 --- a/lib/AST/Module.cpp +++ b/lib/AST/Module.cpp @@ -83,7 +83,7 @@ BuiltinUnit::LookupCache &BuiltinUnit::getCache() const { // FIXME: This leaks. Sticking this into ASTContext isn't enough because then // the DenseMap will leak. if (!Cache) - const_cast(this)->Cache = llvm::make_unique(); + const_cast(this)->Cache = std::make_unique(); return *Cache; } @@ -192,7 +192,7 @@ class swift::SourceLookupCache { SourceLookupCache &SourceFile::getCache() const { if (!Cache) { const_cast(this)->Cache = - llvm::make_unique(*this); + std::make_unique(*this); } return *Cache; } @@ -435,7 +435,7 @@ void ModuleDecl::removeFile(FileUnit &existingFile) { SourceLookupCache &ModuleDecl::getSourceLookupCache() const { if (!Cache) { const_cast(this)->Cache = - llvm::make_unique(*this); + std::make_unique(*this); } return *Cache; } diff --git a/lib/Basic/FileSystem.cpp b/lib/Basic/FileSystem.cpp index 9a323d7c49725..be583f94296ff 100644 --- a/lib/Basic/FileSystem.cpp +++ b/lib/Basic/FileSystem.cpp @@ -214,14 +214,14 @@ swift::areFilesDifferent(const llvm::Twine &source, // The two files match in size, so we have to compare the bytes to determine // if they're the same. std::error_code sourceRegionErr; - fs::mapped_file_region sourceRegion(sourceFile.fd, + fs::mapped_file_region sourceRegion(fs::convertFDToNativeFile(sourceFile.fd), fs::mapped_file_region::readonly, size, 0, sourceRegionErr); if (sourceRegionErr) return sourceRegionErr; std::error_code destRegionErr; - fs::mapped_file_region destRegion(destFile.fd, + fs::mapped_file_region destRegion(fs::convertFDToNativeFile(destFile.fd), fs::mapped_file_region::readonly, size, 0, destRegionErr); diff --git a/lib/Basic/Statistic.cpp b/lib/Basic/Statistic.cpp index 18ee0d31c9d5e..3336f03b54e6f 100644 --- a/lib/Basic/Statistic.cpp +++ b/lib/Basic/Statistic.cpp @@ -221,7 +221,7 @@ class StatsProfiler { if (I != Children.end()) { return I->getSecond().get(); } else { - auto N = llvm::make_unique(this); + auto N = std::make_unique(this); auto P = N.get(); Children.insert(std::make_pair(K, std::move(N))); return P; @@ -344,12 +344,12 @@ UnifiedStatsReporter::UnifiedStatsReporter(StringRef ProgramName, ProfileDirname(Directory), StartedTime(llvm::TimeRecord::getCurrentTime()), MainThreadID(std::this_thread::get_id()), - Timer(make_unique(AuxName, + Timer(std::make_unique(AuxName, "Building Target", ProgramName, "Running Program")), SourceMgr(SM), ClangSourceMgr(CSM), - RecursiveTimers(llvm::make_unique()), + RecursiveTimers(std::make_unique()), IsFlushingTracesAndProfiles(false) { path::append(StatsFilename, makeStatsFileName(ProgramName, AuxName)); @@ -362,9 +362,9 @@ UnifiedStatsReporter::UnifiedStatsReporter(StringRef ProgramName, if (TraceEvents) FrontendStatsEvents.emplace(); if (ProfileEvents) - EventProfilers = make_unique(); + EventProfilers =std::make_unique(); if (ProfileEntities) - EntityProfilers = make_unique(); + EntityProfilers =std::make_unique(); } void UnifiedStatsReporter::recordJobMaxRSS(long rss) { @@ -420,7 +420,7 @@ UnifiedStatsReporter::publishAlwaysOnStatsToLLVM() { auto &C = getFrontendCounters(); #define FRONTEND_STATISTIC(TY, NAME) \ do { \ - static Statistic Stat = {#TY, #NAME, #NAME, {0}, {false}}; \ + static Statistic Stat = {#TY, #NAME, #NAME}; \ Stat += (C).NAME; \ } while (0); #include "swift/Basic/Statistics.def" @@ -430,7 +430,7 @@ UnifiedStatsReporter::publishAlwaysOnStatsToLLVM() { auto &C = getDriverCounters(); #define DRIVER_STATISTIC(NAME) \ do { \ - static Statistic Stat = {"Driver", #NAME, #NAME, {0}, {false}}; \ + static Statistic Stat = {"Driver", #NAME, #NAME}; \ Stat += (C).NAME; \ } while (0); #include "swift/Basic/Statistics.def" diff --git a/lib/Basic/Windows/TaskQueue.inc b/lib/Basic/Windows/TaskQueue.inc index 8ee254ea9a50b..096658582eb70 100755 --- a/lib/Basic/Windows/TaskQueue.inc +++ b/lib/Basic/Windows/TaskQueue.inc @@ -195,7 +195,7 @@ unsigned TaskQueue::getNumberOfParallelTasks() const { void TaskQueue::addTask(const char *ExecPath, ArrayRef Args, ArrayRef Env, void *Context, bool SeparateErrors) { - auto T = llvm::make_unique(ExecPath, Args, Env, Context, SeparateErrors); + auto T = std::make_unique(ExecPath, Args, Env, Context, SeparateErrors); QueuedTasks.push(std::move(T)); } diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp index 6cc87200364bd..42ac126b42cf3 100644 --- a/lib/ClangImporter/ClangImporter.cpp +++ b/lib/ClangImporter/ClangImporter.cpp @@ -33,6 +33,8 @@ #include "swift/Basic/StringExtras.h" #include "swift/Basic/Version.h" #include "swift/ClangImporter/ClangImporterOptions.h" +#include "swift/ClangImporter/ClangModule.h" +#include "swift/Config.h" #include "swift/Demangling/Demangle.h" #include "swift/ClangImporter/ClangModule.h" #include "swift/Config.h" @@ -164,7 +166,7 @@ namespace { SwiftPCHHash(swiftPCHHash) {} std::unique_ptr CreateASTConsumer(clang::CompilerInstance &CI, StringRef InFile) override { - return llvm::make_unique(Impl); + return std::make_unique(Impl); } bool BeginSourceFileAction(clang::CompilerInstance &CI) override { // Prefer frameworks over plain headers. @@ -798,7 +800,7 @@ bool ClangImporter::canReadPCH(StringRef PCHFilename) { CI.createSourceManager(Impl.Instance->getFileManager()); auto &clangSrcMgr = CI.getSourceManager(); auto FID = clangSrcMgr.createFileID( - llvm::make_unique(1, "
")); + std::make_unique(1, "
")); clangSrcMgr.setMainFileID(FID); auto &diagConsumer = CI.getDiagnosticClient(); diagConsumer.BeginSourceFile(CI.getLangOpts()); @@ -810,8 +812,8 @@ bool ClangImporter::canReadPCH(StringRef PCHFilename) { // constructor and the right one for reading a PCH. CI.createPreprocessor(clang::TU_Complete); CI.createASTContext(); - CI.createModuleManager(); - clang::ASTReader &Reader = *CI.getModuleManager(); + CI.createASTReader(); + clang::ASTReader &Reader = *CI.getASTReader(); auto failureCapabilities = clang::ASTReader::ARR_Missing | @@ -995,9 +997,9 @@ ClangImporter::create(ASTContext &ctx, const ClangImporterOptions &importerOpts, auto PCHContainerOperations = std::make_shared(); PCHContainerOperations->registerWriter( - llvm::make_unique()); + std::make_unique()); PCHContainerOperations->registerReader( - llvm::make_unique()); + std::make_unique()); importer->Impl.Instance.reset( new clang::CompilerInstance(std::move(PCHContainerOperations))); } @@ -1010,7 +1012,7 @@ ClangImporter::create(ASTContext &ctx, const ClangImporterOptions &importerOpts, { // Now set up the real client for Clang diagnostics---configured with proper // options---as opposed to the temporary one we made above. - auto actualDiagClient = llvm::make_unique( + auto actualDiagClient = std::make_unique( importer->Impl, instance.getDiagnosticOpts(), importerOpts.DumpClangDiagnostics); instance.createDiagnostics(actualDiagClient.release()); @@ -1089,10 +1091,10 @@ ClangImporter::create(ASTContext &ctx, const ClangImporterOptions &importerOpts, // Setup Preprocessor callbacks before initialing the parser to make sure // we catch implicit includes. - auto ppTracker = llvm::make_unique(importer->Impl); + auto ppTracker = std::make_unique(importer->Impl); clangPP.addPPCallbacks(std::move(ppTracker)); - instance.createModuleManager(); + instance.createASTReader(); // Manually run the action, so that the TU stays open for additional parsing. instance.createSema(action->getTranslationUnitKind(), nullptr); @@ -1209,7 +1211,7 @@ ClangImporter::Implementation::getNextIncludeLoc() { // being deterministic. includeLoc = includeLoc.getLocWithOffset(1); DummyIncludeBuffer = srcMgr.createFileID( - llvm::make_unique( + std::make_unique( 256*1024, StringRef(moduleImportBufferName)), clang::SrcMgr::C_User, /*LoadedID*/0, /*LoadedOffset*/0, includeLoc); } @@ -1500,7 +1502,7 @@ ClangImporter::cloneCompilerInstanceForPrecompiling() { FrontendOpts.DisableFree = false; FrontendOpts.Inputs.clear(); - auto clonedInstance = llvm::make_unique( + auto clonedInstance = std::make_unique( Impl.Instance->getPCHContainerOperations(), &Impl.Instance->getModuleCache()); clonedInstance->setInvocation(std::move(invocation)); @@ -1534,7 +1536,7 @@ ClangImporter::emitBridgingPCH(StringRef headerPath, FrontendOpts.ProgramAction = clang::frontend::GeneratePCH; auto action = wrapActionForIndexingIfEnabled( - FrontendOpts, llvm::make_unique()); + FrontendOpts, std::make_unique()); emitInstance->ExecuteAction(*action); if (emitInstance->getDiagnostics().hasErrorOccurred()) { @@ -1570,7 +1572,7 @@ bool ClangImporter::emitPrecompiledModule(StringRef moduleMapPath, auto action = wrapActionForIndexingIfEnabled( FrontendOpts, - llvm::make_unique()); + std::make_unique()); emitInstance->ExecuteAction(*action); if (emitInstance->getDiagnostics().hasErrorOccurred()) { @@ -1595,7 +1597,7 @@ bool ClangImporter::dumpPrecompiledModule(StringRef modulePath, FrontendOpts.Inputs = {inputFile}; FrontendOpts.OutputFile = outputPath; - auto action = llvm::make_unique(); + auto action = std::make_unique(); dumpInstance->ExecuteAction(*action); if (dumpInstance->getDiagnostics().hasErrorOccurred()) { @@ -1830,7 +1832,7 @@ ModuleDecl *ClangImporter::Implementation::finishLoadingClangModule( // finishLoadingClangModule on each. void ClangImporter::Implementation::handleDeferredImports() { - clang::ASTReader &R = *Instance->getModuleManager(); + clang::ASTReader &R = *Instance->getASTReader(); llvm::SmallSet seenSubmodules; for (clang::serialization::SubmoduleID ID : PCHImportedSubmodules) { if (!seenSubmodules.insert(ID).second) @@ -3228,7 +3230,7 @@ Decl *ClangImporter::importDeclCached(const clang::NamedDecl *ClangDecl) { } void ClangImporter::printStatistics() const { - Impl.Instance->getModuleManager()->PrintStats(); + Impl.Instance->getASTReader()->PrintStats(); } void ClangImporter::verifyAllModules() { diff --git a/lib/ClangImporter/ImportName.cpp b/lib/ClangImporter/ImportName.cpp index 2200bd6d78509..39feebe76ab6d 100644 --- a/lib/ClangImporter/ImportName.cpp +++ b/lib/ClangImporter/ImportName.cpp @@ -1860,7 +1860,7 @@ const InheritedNameSet *NameImporter::getAllPropertyNames( llvm::BumpPtrAllocator &alloc = scratch.getAllocator(); known = allProperties.insert({ std::pair(classDecl, forInstance), - llvm::make_unique(parentSet, alloc) }).first; + std::make_unique(parentSet, alloc) }).first; // Local function to add properties from the given set. auto addProperties = [&](clang::DeclContext::decl_range members) { diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp index 854a4f29d78fa..3d067ef2fdab5 100644 --- a/lib/ClangImporter/ImportType.cpp +++ b/lib/ClangImporter/ImportType.cpp @@ -15,9 +15,8 @@ //===----------------------------------------------------------------------===// #include "CFTypeInfo.h" -#include "ImporterImpl.h" #include "ClangDiagnosticConsumer.h" -#include "swift/Strings.h" +#include "ImporterImpl.h" #include "swift/ABI/MetadataValues.h" #include "swift/AST/ASTContext.h" #include "swift/AST/Decl.h" @@ -31,11 +30,13 @@ #include "swift/AST/Types.h" #include "swift/ClangImporter/ClangModule.h" #include "swift/Parse/Token.h" -#include "clang/Sema/Lookup.h" -#include "clang/Sema/Sema.h" -#include "clang/Lex/Preprocessor.h" +#include "swift/Strings.h" #include "clang/AST/ASTContext.h" #include "clang/AST/TypeVisitor.h" +#include "clang/Basic/Builtins.h" +#include "clang/Lex/Preprocessor.h" +#include "clang/Sema/Lookup.h" +#include "clang/Sema/Sema.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/Compiler.h" diff --git a/lib/ClangImporter/SwiftLookupTable.cpp b/lib/ClangImporter/SwiftLookupTable.cpp index 0aa7476df5d55..0303aff556545 100644 --- a/lib/ClangImporter/SwiftLookupTable.cpp +++ b/lib/ClangImporter/SwiftLookupTable.cpp @@ -1738,7 +1738,7 @@ SwiftLookupTableReader::create(clang::ModuleFileExtension *extension, if (!serializedTable) return nullptr; // Create the reader. - // Note: This doesn't use llvm::make_unique because the constructor is + // Note: This doesn't use std::make_unique because the constructor is // private. return std::unique_ptr( new SwiftLookupTableReader(extension, reader, moduleFile, onRemove, @@ -2073,10 +2073,10 @@ void SwiftLookupTableWriter::populateTable(SwiftLookupTable &table, std::unique_ptr SwiftNameLookupExtension::createExtensionWriter(clang::ASTWriter &writer) { - return llvm::make_unique(this, writer, swiftCtx, - buffersForDiagnostics, - availability, - inferImportAsMember); + return std::make_unique(this, writer, swiftCtx, + buffersForDiagnostics, + availability, + inferImportAsMember); } std::unique_ptr diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp index d596d4ebdbb5f..ca7f2efccb7e6 100644 --- a/lib/Driver/Driver.cpp +++ b/lib/Driver/Driver.cpp @@ -259,22 +259,22 @@ Driver::buildToolChain(const llvm::opt::InputArgList &ArgList) { if (const Arg *A = ArgList.getLastArg(options::OPT_target_variant)) targetVariant = llvm::Triple(llvm::Triple::normalize(A->getValue())); - return llvm::make_unique(*this, target, targetVariant); + return std::make_unique(*this, target, targetVariant); } case llvm::Triple::Linux: if (target.isAndroid()) - return llvm::make_unique(*this, target); - return llvm::make_unique(*this, target); + return std::make_unique(*this, target); + return std::make_unique(*this, target); case llvm::Triple::FreeBSD: - return llvm::make_unique(*this, target); + return std::make_unique(*this, target); case llvm::Triple::Win32: if (target.isWindowsCygwinEnvironment()) - return llvm::make_unique(*this, target); - return llvm::make_unique(*this, target); + return std::make_unique(*this, target); + return std::make_unique(*this, target); case llvm::Triple::Haiku: - return llvm::make_unique(*this, target); + return std::make_unique(*this, target); case llvm::Triple::WASI: - return llvm::make_unique(*this, target); + return std::make_unique(*this, target); default: Diags.diagnose(SourceLoc(), diag::error_unknown_target, ArgList.getLastArg(options::OPT_target)->getValue()); @@ -303,9 +303,9 @@ std::unique_ptr Driver::buildTaskQueue(const Compilation &C) { ArgList.hasArg(options::OPT_driver_skip_execution, options::OPT_driver_print_jobs); if (DriverSkipExecution) { - return llvm::make_unique(NumberOfParallelCommands); + return std::make_unique(NumberOfParallelCommands); } else { - return llvm::make_unique(NumberOfParallelCommands, + return std::make_unique(NumberOfParallelCommands, C.getStatsReporter()); } } @@ -768,7 +768,7 @@ createStatsReporter(const llvm::opt::InputArgList *ArgList, InputName = Inputs[0].second->getSpelling(); } StringRef OutputType = file_types::getExtension(OI.CompilerOutputType); - return llvm::make_unique("swift-driver", + return std::make_unique("swift-driver", OI.ModuleName, InputName, DefaultTargetTriple, @@ -988,7 +988,7 @@ Driver::buildCompilation(const ToolChain &TC, ArgList->hasArg(options::OPT_fine_grained_dependency_include_intrafile); // clang-format off - C = llvm::make_unique( + C = std::make_unique( Diags, TC, OI, Level, std::move(ArgList), std::move(TranslatedArgList), @@ -1085,7 +1085,7 @@ parseArgsUntil(const llvm::opt::OptTable& Opts, unsigned FlagsToExclude, llvm::opt::OptSpecifier UntilOption, RemainingArgsHandler RemainingHandler) { - auto Args = llvm::make_unique(ArgBegin, ArgEnd); + auto Args = std::make_unique(ArgBegin, ArgEnd); // FIXME: Handle '@' args (or at least error on them). @@ -1163,7 +1163,7 @@ Driver::parseArgStrings(ArrayRef Args) { ExcludedFlagsBitmask); } else { - ArgList = llvm::make_unique( + ArgList = std::make_unique( getOpts().ParseArgs(Args, MissingArgIndex, MissingArgCount, IncludedFlagsBitmask, ExcludedFlagsBitmask)); } diff --git a/lib/Driver/ToolChain.cpp b/lib/Driver/ToolChain.cpp index 87398eecadb9b..cb63ebc51e058 100644 --- a/lib/Driver/ToolChain.cpp +++ b/lib/Driver/ToolChain.cpp @@ -145,7 +145,7 @@ std::unique_ptr ToolChain::constructJob( auto responseFileInfo = getResponseFileInfo(C, executablePath, invocationInfo, context); - return llvm::make_unique( + return std::make_unique( JA, std::move(inputs), std::move(output), executablePath, std::move(invocationInfo.Arguments), std::move(invocationInfo.ExtraEnvironment), @@ -240,7 +240,7 @@ static std::unique_ptr makeBatchCommandOutput(ArrayRef jobs, Compilation &C, file_types::ID outputType) { auto output = - llvm::make_unique(outputType, C.getDerivedOutputFileMap()); + std::make_unique(outputType, C.getDerivedOutputFileMap()); for (auto const *J : jobs) { output->addOutputs(J->getOutput()); } @@ -333,7 +333,7 @@ ToolChain::constructBatchJob(ArrayRef unsortedJobs, auto responseFileInfo = getResponseFileInfo(C, executablePath, invocationInfo, context); - return llvm::make_unique( + return std::make_unique( *batchCJA, inputJobs.takeVector(), std::move(output), executablePath, std::move(invocationInfo.Arguments), std::move(invocationInfo.ExtraEnvironment), diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp index 9e10950b6db40..bca1c7b898e9f 100644 --- a/lib/Frontend/Frontend.cpp +++ b/lib/Frontend/Frontend.cpp @@ -843,7 +843,7 @@ void CompilerInstance::parseAndCheckTypesUpTo( const ImplicitImports &implicitImports, SourceFile::ASTStage_t limitStage) { FrontendStatsTracer tracer(Context->Stats, "parse-and-check-types"); - PersistentState = llvm::make_unique(); + PersistentState = std::make_unique(); bool hadLoadError = parsePartialModulesAndLibraryFiles(implicitImports); if (Invocation.isCodeCompletion()) { @@ -1058,7 +1058,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals, MainBufferID); } - PersistentState = llvm::make_unique(); + PersistentState = std::make_unique(); PersistentState->PerformConditionEvaluation = EvaluateConditionals; auto shouldDelayBodies = [&](unsigned bufferID) -> bool { diff --git a/lib/Frontend/ModuleInterfaceBuilder.h b/lib/Frontend/ModuleInterfaceBuilder.h index b5de3c64b8a8e..78028132f25db 100644 --- a/lib/Frontend/ModuleInterfaceBuilder.h +++ b/lib/Frontend/ModuleInterfaceBuilder.h @@ -17,6 +17,7 @@ #include "swift/Basic/SourceLoc.h" #include "swift/Frontend/Frontend.h" #include "swift/Serialization/SerializationOptions.h" +#include "llvm/Support/StringSaver.h" namespace llvm { namespace vfs { diff --git a/lib/Frontend/SerializedDiagnosticConsumer.cpp b/lib/Frontend/SerializedDiagnosticConsumer.cpp index 001063e817f90..ae66990fcd7ac 100644 --- a/lib/Frontend/SerializedDiagnosticConsumer.cpp +++ b/lib/Frontend/SerializedDiagnosticConsumer.cpp @@ -238,7 +238,7 @@ class SerializedDiagnosticConsumer : public DiagnosticConsumer { namespace swift { namespace serialized_diagnostics { std::unique_ptr createConsumer(StringRef outputPath) { - return llvm::make_unique(outputPath); + return std::make_unique(outputPath); } } // namespace serialized_diagnostics } // namespace swift diff --git a/lib/FrontendTool/FrontendTool.cpp b/lib/FrontendTool/FrontendTool.cpp index 912ce5cc572f8..c7b35f7a2c2df 100644 --- a/lib/FrontendTool/FrontendTool.cpp +++ b/lib/FrontendTool/FrontendTool.cpp @@ -471,7 +471,7 @@ emitLoadedModuleTraceForAllPrimariesIfNeeded(ModuleDecl *mainModule, static std::unique_ptr getFileOutputStream(StringRef OutputFilename, ASTContext &Ctx) { std::error_code errorCode; - auto os = llvm::make_unique( + auto os = std::make_unique( OutputFilename, errorCode, llvm::sys::fs::F_None); if (errorCode) { Ctx.Diags.diagnose(SourceLoc(), diag::error_opening_output, @@ -713,7 +713,7 @@ createOptRecordFile(StringRef Filename, DiagnosticEngine &DE) { return nullptr; std::error_code EC; - auto File = llvm::make_unique(Filename, EC, + auto File = std::make_unique(Filename, EC, llvm::sys::fs::F_None); if (EC) { DE.diagnose(SourceLoc(), diag::cannot_open_file, Filename, EC.message()); @@ -1520,7 +1520,7 @@ static bool performCompileStepsPostSILGen( createOptRecordFile(SILOpts.OptRecordFile, Instance.getDiags()); if (OptRecordFile) { auto Output = - llvm::make_unique(*OptRecordFile, + std::make_unique(*OptRecordFile, &Instance.getSourceMgr()); SM->setOptRecordStream(std::move(Output), std::move(OptRecordFile)); } @@ -1796,7 +1796,7 @@ computeStatsReporter(const CompilerInvocation &Invocation, CompilerInstance *Ins Instance->getASTContext().getClangModuleLoader())) { CSM = &clangImporter->getClangASTContext().getSourceManager(); } - return llvm::make_unique( + return std::make_unique( "swift-frontend", FEOpts.ModuleName, InputName, TripleName, OutputType, OptType, StatsOutputDir, SM, CSM, Trace, ProfileEvents, ProfileEntities); @@ -1889,7 +1889,7 @@ createJSONFixItDiagnosticConsumerIfNeeded( std::string fixItsOutputPath = input.fixItsOutputPath(); if (fixItsOutputPath.empty()) return nullptr; - return llvm::make_unique( + return std::make_unique( fixItsOutputPath, invocation.getDiagnosticOptions()); }); } @@ -1982,6 +1982,7 @@ int swift::performFrontend(ArrayRef Args, const char *Argv0, void *MainAddr, FrontendObserver *observer) { INITIALIZE_LLVM(); + llvm::EnablePrettyStackTraceOnSigInfoForThisThread(); PrintingDiagnosticConsumer PDC; @@ -2022,7 +2023,7 @@ int swift::performFrontend(ArrayRef Args, }, &diagnoseFatalError); std::unique_ptr Instance = - llvm::make_unique(); + std::make_unique(); Instance->addDiagnosticConsumer(&PDC); struct FinishDiagProcessingCheckRAII { @@ -2070,7 +2071,7 @@ int swift::performFrontend(ArrayRef Args, // dynamically-sized array of optional PrettyStackTraces, which get // initialized by iterating over the buffers we collected above. auto configurationFileStackTraces = - llvm::make_unique[]>( + std::make_unique[]>( configurationFileBuffers.size()); for_each(configurationFileBuffers.begin(), configurationFileBuffers.end(), &configurationFileStackTraces[0], diff --git a/lib/IDE/Refactoring.cpp b/lib/IDE/Refactoring.cpp index 9ce2bc7739024..8ceded06c3da7 100644 --- a/lib/IDE/Refactoring.cpp +++ b/lib/IDE/Refactoring.cpp @@ -1077,7 +1077,7 @@ getNotableRegions(StringRef SourceText, unsigned NameOffset, StringRef Name, InputFile("", true, InputBuffer.get())); Invocation.getFrontendOptions().ModuleName = "extract"; - auto Instance = llvm::make_unique(); + auto Instance = std::make_unique(); if (Instance->setup(Invocation)) llvm_unreachable("Failed setup"); @@ -1763,8 +1763,8 @@ findConcatenatedExpressions(ResolvedRangeInfo Info, ASTContext &Ctx) { assert(E); struct StringInterpolationExprFinder: public SourceEntityWalker { - std::unique_ptr> Bucket = llvm:: - make_unique>(); + std::unique_ptr> Bucket = + std::make_unique>(); ASTContext &Ctx; bool IsValidInterpolation = true; @@ -1995,11 +1995,11 @@ findExpandableTernaryExpression(ResolvedRangeInfo Info) { if (auto D = Info.ContainedNodes[0].dyn_cast()) if (auto Binding = dyn_cast(D)) - return llvm::make_unique(Binding); + return std::make_unique(Binding); if (auto E = Info.ContainedNodes[0].dyn_cast()) if (auto Assign = dyn_cast(E)) - return llvm::make_unique(Assign); + return std::make_unique(Assign); return nullptr; } diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp index a3ca1b1d07bdc..8688ceeff8aa1 100644 --- a/lib/IRGen/GenBuiltin.cpp +++ b/lib/IRGen/GenBuiltin.cpp @@ -417,7 +417,7 @@ if (Builtin.ID == BuiltinValueKind::id) { \ if (Builtin.ID == BuiltinValueKind::AssumeTrue) { llvm::Value *v = args.claimNext(); if (v->getType() == IGF.IGM.Int1Ty) { - IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::assume, v); + IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::assume, v); } return; } diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp index 8dbfb7847f052..db623ab9f4694 100644 --- a/lib/IRGen/GenCall.cpp +++ b/lib/IRGen/GenCall.cpp @@ -205,8 +205,8 @@ void irgen::addByvalArgumentAttributes(IRGenModule &IGM, unsigned argIndex, Alignment align) { llvm::AttrBuilder b; b.addAttribute(llvm::Attribute::ByVal); - b.addAttribute(llvm::Attribute::getWithAlignment(IGM.LLVMContext, - align.getValue())); + b.addAttribute(llvm::Attribute::getWithAlignment( + IGM.LLVMContext, llvm::Align(align.getValue()))); attrs = attrs.addAttributes(IGM.LLVMContext, argIndex + llvm::AttributeList::FirstArgIndex, b); } @@ -1617,10 +1617,9 @@ llvm::CallSite CallEmission::emitCallSite() { auto origCallee = call->getCalledValue(); llvm::Value *opaqueCallee = origCallee; opaqueCallee = - IGF.Builder.CreateBitCast(opaqueCallee, IGF.IGM.Int8PtrTy); - opaqueCallee = - IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_prepare_retcon, - { opaqueCallee }); + IGF.Builder.CreateBitCast(opaqueCallee, IGF.IGM.Int8PtrTy); + opaqueCallee = IGF.Builder.CreateIntrinsicCall( + llvm::Intrinsic::coro_prepare_retcon, {opaqueCallee}); opaqueCallee = IGF.Builder.CreateBitCast(opaqueCallee, origCallee->getType()); call->setCalledFunction(fn.getFunctionType(), opaqueCallee); @@ -1743,7 +1742,8 @@ void CallEmission::emitYieldsToExplosion(Explosion &out) { auto indirectStructTy = cast( indirectPointer->getType()->getPointerElementType()); auto layout = IGF.IGM.DataLayout.getStructLayout(indirectStructTy); - Address indirectBuffer(indirectPointer, Alignment(layout->getAlignment())); + Address indirectBuffer(indirectPointer, + Alignment(layout->getAlignment().value())); for (auto i : indices(indirectStructTy->elements())) { // Skip padding. @@ -2075,10 +2075,11 @@ static void emitCoerceAndExpand(IRGenFunction &IGF, Explosion &in, // Make the alloca at least as aligned as the coercion struct, just // so that the element accesses we make don't end up under-aligned. - Alignment coercionTyAlignment = Alignment(coercionTyLayout->getAlignment()); + Alignment coercionTyAlignment = + Alignment(coercionTyLayout->getAlignment().value()); auto alloca = cast(temporary.getAddress()); if (alloca->getAlignment() < coercionTyAlignment.getValue()) { - alloca->setAlignment(coercionTyAlignment.getValue()); + alloca->setAlignment(llvm::MaybeAlign(coercionTyAlignment.getValue())); temporary = Address(temporary.getAddress(), coercionTyAlignment); } @@ -2355,7 +2356,7 @@ static void externalizeArguments(IRGenFunction &IGF, const Callee &callee, auto ABIAlign = AI.getIndirectAlign(); if (ABIAlign > addr.getAlignment()) { auto *AS = cast(addr.getAddress()); - AS->setAlignment(ABIAlign.getQuantity()); + AS->setAlignment(llvm::MaybeAlign(ABIAlign.getQuantity())); addr = Address(addr.getAddress(), Alignment(ABIAlign.getQuantity())); } } @@ -2584,10 +2585,9 @@ static void emitRetconCoroutineEntry(IRGenFunction &IGF, // Call 'llvm.coro.begin', just for consistency with the normal pattern. // This serves as a handle that we can pass around to other intrinsics. - auto hdl = IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_begin, { - id, - llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy) - }); + auto hdl = IGF.Builder.CreateIntrinsicCall( + llvm::Intrinsic::coro_begin, + {id, llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy)}); // Set the coroutine handle; this also flags that is a coroutine so that // e.g. dynamic allocas use the right code generation. @@ -2598,7 +2598,7 @@ void irgen::emitYieldOnceCoroutineEntry(IRGenFunction &IGF, CanSILFunctionType fnType, Explosion &allParamValues) { emitRetconCoroutineEntry(IGF, fnType, allParamValues, - llvm::Intrinsic::ID::coro_id_retcon_once, + llvm::Intrinsic::coro_id_retcon_once, getYieldOnceCoroutineBufferSize(IGF.IGM), getYieldOnceCoroutineBufferAlignment(IGF.IGM)); } @@ -2607,7 +2607,7 @@ void irgen::emitYieldManyCoroutineEntry(IRGenFunction &IGF, CanSILFunctionType fnType, Explosion &allParamValues) { emitRetconCoroutineEntry(IGF, fnType, allParamValues, - llvm::Intrinsic::ID::coro_id_retcon, + llvm::Intrinsic::coro_id_retcon, getYieldManyCoroutineBufferSize(IGF.IGM), getYieldManyCoroutineBufferAlignment(IGF.IGM)); } @@ -2684,8 +2684,8 @@ llvm::Value *irgen::emitYield(IRGenFunction &IGF, resultStructTy->getElementType(resultStructTy->getNumElements() - 1) ->getPointerElementType()); auto layout = IGF.IGM.DataLayout.getStructLayout(bufferStructTy); - indirectBuffer = IGF.createAlloca(bufferStructTy, - Alignment(layout->getAlignment())); + indirectBuffer = IGF.createAlloca( + bufferStructTy, Alignment(layout->getAlignment().value())); indirectBufferSize = Size(layout->getSizeInBytes()); IGF.Builder.CreateLifetimeStart(*indirectBuffer, indirectBufferSize); @@ -2709,10 +2709,8 @@ llvm::Value *irgen::emitYield(IRGenFunction &IGF, } // Perform the yield. - auto isUnwind = - IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_suspend_retcon, - { IGF.IGM.Int1Ty }, - yieldArgs); + auto isUnwind = IGF.Builder.CreateIntrinsicCall( + llvm::Intrinsic::coro_suspend_retcon, {IGF.IGM.Int1Ty}, yieldArgs); // We're done with the indirect buffer. if (indirectBuffer) { @@ -3030,10 +3028,10 @@ void IRGenFunction::emitScalarReturn(llvm::Type *resultType, static void adjustAllocaAlignment(const llvm::DataLayout &DL, Address allocaAddr, llvm::StructType *type) { auto layout = DL.getStructLayout(type); - Alignment layoutAlignment = Alignment(layout->getAlignment()); + Alignment layoutAlignment = Alignment(layout->getAlignment().value()); auto alloca = cast(allocaAddr.getAddress()); if (alloca->getAlignment() < layoutAlignment.getValue()) { - alloca->setAlignment(layoutAlignment.getValue()); + alloca->setAlignment(llvm::MaybeAlign(layoutAlignment.getValue())); allocaAddr = Address(allocaAddr.getAddress(), layoutAlignment); } } diff --git a/lib/IRGen/GenClangType.cpp b/lib/IRGen/GenClangType.cpp index 16b4a9b6ac638..53419d7cb82c3 100644 --- a/lib/IRGen/GenClangType.cpp +++ b/lib/IRGen/GenClangType.cpp @@ -366,7 +366,7 @@ clang::CanQualType GenClangType::visitTupleType(CanTupleType type) { APInt size(32, e); auto &ctx = getClangASTContext(); return ctx.getCanonicalType( - ctx.getConstantArrayType(clangEltTy, size, + ctx.getConstantArrayType(clangEltTy, size, nullptr, clang::ArrayType::Normal, 0)); } diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp index fbefa083a58a1..c868b792663f5 100644 --- a/lib/IRGen/GenDecl.cpp +++ b/lib/IRGen/GenDecl.cpp @@ -4266,7 +4266,7 @@ Address IRGenFunction::createAlloca(llvm::Type *type, llvm::AllocaInst *alloca = new llvm::AllocaInst(type, IGM.DataLayout.getAllocaAddrSpace(), name, AllocaIP); - alloca->setAlignment(alignment.getValue()); + alloca->setAlignment(llvm::MaybeAlign(alignment.getValue())); return Address(alloca, alignment); } @@ -4275,9 +4275,9 @@ Address IRGenFunction::createAlloca(llvm::Type *type, llvm::Value *ArraySize, Alignment alignment, const llvm::Twine &name) { - llvm::AllocaInst *alloca = - new llvm::AllocaInst(type, IGM.DataLayout.getAllocaAddrSpace(), ArraySize, - alignment.getValue(), name, AllocaIP); + llvm::AllocaInst *alloca = new llvm::AllocaInst( + type, IGM.DataLayout.getAllocaAddrSpace(), ArraySize, + llvm::MaybeAlign(alignment.getValue()), name, AllocaIP); return Address(alloca, alignment); } @@ -4602,9 +4602,8 @@ IRGenModule::getOrCreateHelperFunction(StringRef fnName, llvm::Type *resultTy, llvm::FunctionType::get(resultTy, paramTys, false); llvm::Constant *fn = - cast(Module.getOrInsertFunction(fnName, fnTy) - .getCallee() - ->stripPointerCasts()); + cast( + Module.getOrInsertFunction(fnName, fnTy).getCallee()); if (llvm::Function *def = shouldDefineHelper(*this, fn, setIsNoInline)) { IRGenFunction IGF(*this, def); diff --git a/lib/IRGen/GenDecl.h b/lib/IRGen/GenDecl.h index 93656316c6a0c..40b011b272371 100644 --- a/lib/IRGen/GenDecl.h +++ b/lib/IRGen/GenDecl.h @@ -20,6 +20,7 @@ #include "swift/Basic/OptimizationMode.h" #include "swift/SIL/SILLocation.h" #include "llvm/IR/CallingConv.h" +#include "llvm/Support/CommandLine.h" #include "DebugTypeInfo.h" #include "IRGen.h" diff --git a/lib/IRGen/GenOpaque.cpp b/lib/IRGen/GenOpaque.cpp index a2e8097ea043b..c8c34e891ebcd 100644 --- a/lib/IRGen/GenOpaque.cpp +++ b/lib/IRGen/GenOpaque.cpp @@ -523,12 +523,12 @@ StackAddress IRGenFunction::emitDynamicAlloca(llvm::Type *eltTy, // Allocate memory. This produces an abstract token. auto allocFn = llvm::Intrinsic::getDeclaration( - &IGM.Module, llvm::Intrinsic::ID::coro_alloca_alloc, { IGM.SizeTy }); + &IGM.Module, llvm::Intrinsic::coro_alloca_alloc, {IGM.SizeTy}); auto allocToken = Builder.CreateCall(allocFn, { byteCount, alignment }); // Get the allocation result. auto getFn = llvm::Intrinsic::getDeclaration( - &IGM.Module, llvm::Intrinsic::ID::coro_alloca_get); + &IGM.Module, llvm::Intrinsic::coro_alloca_get); auto ptr = Builder.CreateCall(getFn, { allocToken }); return {Address(ptr, align), allocToken}; @@ -542,14 +542,14 @@ StackAddress IRGenFunction::emitDynamicAlloca(llvm::Type *eltTy, bool isInEntryBlock = (Builder.GetInsertBlock() == &*CurFn->begin()); if (!isInEntryBlock) { auto *stackSaveFn = llvm::Intrinsic::getDeclaration( - &IGM.Module, llvm::Intrinsic::ID::stacksave); + &IGM.Module, llvm::Intrinsic::stacksave); stackRestorePoint = Builder.CreateCall(stackSaveFn, {}, "spsave"); } // Emit the dynamic alloca. auto *alloca = Builder.IRBuilderBase::CreateAlloca(eltTy, arraySize, name); - alloca->setAlignment(align.getValue()); + alloca->setAlignment(llvm::MaybeAlign(align.getValue())); assert(!isInEntryBlock || getActiveDominancePoint().isUniversal() && @@ -569,7 +569,7 @@ void IRGenFunction::emitDeallocateDynamicAlloca(StackAddress address) { auto allocToken = address.getExtraInfo(); assert(allocToken && "dynamic alloca in coroutine without alloc token?"); auto freeFn = llvm::Intrinsic::getDeclaration( - &IGM.Module, llvm::Intrinsic::ID::coro_alloca_free); + &IGM.Module, llvm::Intrinsic::coro_alloca_free); Builder.CreateCall(freeFn, allocToken); return; } @@ -578,7 +578,7 @@ void IRGenFunction::emitDeallocateDynamicAlloca(StackAddress address) { if (savedSP == nullptr) return; auto *stackRestoreFn = llvm::Intrinsic::getDeclaration( - &IGM.Module, llvm::Intrinsic::ID::stackrestore); + &IGM.Module, llvm::Intrinsic::stackrestore); Builder.CreateCall(stackRestoreFn, savedSP); } diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp index 022cc0496abbe..cd0ddbd9b6604 100644 --- a/lib/IRGen/GenStruct.cpp +++ b/lib/IRGen/GenStruct.cpp @@ -26,6 +26,7 @@ #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/RecordLayout.h" #include "clang/CodeGen/SwiftCallingConv.h" diff --git a/lib/IRGen/IRBuilder.h b/lib/IRGen/IRBuilder.h index e53534579890c..6826c18be8597 100644 --- a/lib/IRGen/IRBuilder.h +++ b/lib/IRGen/IRBuilder.h @@ -125,7 +125,7 @@ class IRBuilder : public IRBuilderBase { llvm::LoadInst *CreateLoad(llvm::Value *addr, Alignment align, const llvm::Twine &name = "") { llvm::LoadInst *load = IRBuilderBase::CreateLoad(addr, name); - load->setAlignment(align.getValue()); + load->setAlignment(llvm::MaybeAlign(align.getValue())); return load; } llvm::LoadInst *CreateLoad(Address addr, const llvm::Twine &name = "") { @@ -135,7 +135,7 @@ class IRBuilder : public IRBuilderBase { llvm::StoreInst *CreateStore(llvm::Value *value, llvm::Value *addr, Alignment align) { llvm::StoreInst *store = IRBuilderBase::CreateStore(value, addr); - store->setAlignment(align.getValue()); + store->setAlignment(llvm::MaybeAlign(align.getValue())); return store; } llvm::StoreInst *CreateStore(llvm::Value *value, Address addr) { @@ -216,12 +216,12 @@ class IRBuilder : public IRBuilderBase { using IRBuilderBase::CreateMemSet; llvm::CallInst *CreateMemSet(Address dest, llvm::Value *value, Size size) { return CreateMemSet(dest.getAddress(), value, size.getValue(), - dest.getAlignment().getValue()); + llvm::MaybeAlign(dest.getAlignment().getValue())); } llvm::CallInst *CreateMemSet(Address dest, llvm::Value *value, llvm::Value *size) { return CreateMemSet(dest.getAddress(), value, size, - dest.getAlignment().getValue()); + llvm::MaybeAlign(dest.getAlignment().getValue())); } using IRBuilderBase::CreateLifetimeStart; @@ -241,11 +241,11 @@ class IRBuilder : public IRBuilderBase { // FunctionPointer. bool isTrapIntrinsic(llvm::Value *Callee) { - return Callee == llvm::Intrinsic::getDeclaration(getModule(), - llvm::Intrinsic::ID::trap); + return Callee == + llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::trap); } bool isTrapIntrinsic(llvm::Intrinsic::ID intrinsicID) { - return intrinsicID == llvm::Intrinsic::ID::trap; + return intrinsicID == llvm::Intrinsic::trap; } llvm::CallInst *CreateCall(llvm::Value *Callee, ArrayRef Args, diff --git a/lib/IRGen/IRGen.cpp b/lib/IRGen/IRGen.cpp index a39ff7e63e4cd..096cb8212fa76 100644 --- a/lib/IRGen/IRGen.cpp +++ b/lib/IRGen/IRGen.cpp @@ -72,6 +72,7 @@ #include "llvm/Transforms/IPO/PassManagerBuilder.h" #include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Instrumentation/AddressSanitizer.h" +#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h" #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h" #include "llvm/Transforms/ObjCARC.h" @@ -146,7 +147,7 @@ static void addSanitizerCoveragePass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) { const PassManagerBuilderWrapper &BuilderWrapper = static_cast(Builder); - PM.add(createSanitizerCoverageModulePass( + PM.add(createModuleSanitizerCoverageLegacyPassPass( BuilderWrapper.IRGOpts.SanitizeCoverage)); } @@ -391,8 +392,13 @@ static bool needsRecompile(StringRef OutputFilename, ArrayRef HashData, // Search for the section which holds the hash. for (auto &Section : ObjectFile->sections()) { - StringRef SectionName; - Section.getName(SectionName); + llvm::Expected SectionNameOrErr = Section.getName(); + if (!SectionNameOrErr) { + llvm::consumeError(SectionNameOrErr.takeError()); + continue; + } + + StringRef SectionName = *SectionNameOrErr; if (SectionName == HashSectionName) { llvm::Expected SectionData = Section.getContents(); if (!SectionData) { @@ -572,10 +578,10 @@ bool swift::performLLVM(const IRGenOptions &Opts, DiagnosticEngine *Diags, break; case IRGenOutputKind::NativeAssembly: case IRGenOutputKind::ObjectFile: { - llvm::TargetMachine::CodeGenFileType FileType; + CodeGenFileType FileType; FileType = (Opts.OutputKind == IRGenOutputKind::NativeAssembly - ? llvm::TargetMachine::CGFT_AssemblyFile - : llvm::TargetMachine::CGFT_ObjectFile); + ? CGFT_AssemblyFile + : CGFT_ObjectFile); EmitPasses.add(createTargetTransformInfoWrapperPass( TargetMachine->getTargetIRAnalysis())); diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp index 8cbdd8095e06d..f41ede44f1991 100644 --- a/lib/IRGen/IRGenDebugInfo.cpp +++ b/lib/IRGen/IRGenDebugInfo.cpp @@ -1608,7 +1608,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo { ClangDecl = ND->getClangDecl(); } if (ClangDecl) { - clang::ASTReader &Reader = *CI.getClangInstance().getModuleManager(); + clang::ASTReader &Reader = *CI.getClangInstance().getASTReader(); auto Idx = ClangDecl->getOwningModuleID(); auto SubModuleDesc = Reader.getSourceDescriptor(Idx); auto TopLevelModuleDesc = getClangModule(*TypeDecl->getModuleContext()); @@ -2313,7 +2313,8 @@ void IRGenDebugInfoImpl::emitGlobalVariableDeclaration( if (!Var) Expr = DBuilder.createConstantValueExpression(0); auto *GV = DBuilder.createGlobalVariableExpression( - MainModule, Name, LinkageName, File, L.Line, DITy, IsLocalToUnit, Expr); + MainModule, Name, LinkageName, File, L.Line, DITy, IsLocalToUnit, true, + Expr); if (Var) Var->addDebugInfo(GV); } @@ -2359,7 +2360,7 @@ std::unique_ptr IRGenDebugInfo::createIRGenDebugInfo( const IRGenOptions &Opts, ClangImporter &CI, IRGenModule &IGM, llvm::Module &M, StringRef MainOutputFilenameForDebugInfo, StringRef PrivateDiscriminator) { - return llvm::make_unique(Opts, CI, IGM, M, + return std::make_unique(Opts, CI, IGM, M, MainOutputFilenameForDebugInfo, PrivateDiscriminator); } diff --git a/lib/IRGen/IRGenFunction.cpp b/lib/IRGen/IRGenFunction.cpp index 4eb3118264e75..007aed1e1195f 100644 --- a/lib/IRGen/IRGenFunction.cpp +++ b/lib/IRGen/IRGenFunction.cpp @@ -20,6 +20,7 @@ #include "swift/IRGen/Linking.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/Function.h" +#include "llvm/Support/CommandLine.h" #include "llvm/Support/raw_ostream.h" #include "Explosion.h" @@ -456,7 +457,7 @@ llvm::CallInst *IRBuilder::CreateNonMergeableTrap(IRGenModule &IGM, // Emit the trap instruction. llvm::Function *trapIntrinsic = - llvm::Intrinsic::getDeclaration(&IGM.Module, llvm::Intrinsic::ID::trap); + llvm::Intrinsic::getDeclaration(&IGM.Module, llvm::Intrinsic::trap); if (EnableTrapDebugInfo && IGM.DebugInfo && !failureMsg.empty()) { IGM.DebugInfo->addFailureMessageToCurrentLoc(*this, failureMsg); } diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp index 7292f9e0160ca..b7a38be2795e9 100644 --- a/lib/IRGen/IRGenSIL.cpp +++ b/lib/IRGen/IRGenSIL.cpp @@ -676,7 +676,7 @@ class IRGenSILFunction : ZeroInitBuilder.SetCurrentDebugLocation(nullptr); ZeroInitBuilder.CreateMemSet( AI, llvm::ConstantInt::get(IGM.Int8Ty, 0), - Size, AI->getAlignment()); + Size, llvm::MaybeAlign(AI->getAlignment())); } /// Account for bugs in LLVM. @@ -2567,10 +2567,9 @@ static void emitCoroutineExit(IRGenSILFunction &IGF) { // Emit the block. IGF.Builder.emitBlock(coroEndBB); auto handle = IGF.getCoroutineHandle(); - IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::ID::coro_end, { - handle, - /*is unwind*/ IGF.Builder.getFalse() - }); + IGF.Builder.CreateIntrinsicCall(llvm::Intrinsic::coro_end, + {handle, + /*is unwind*/ IGF.Builder.getFalse()}); IGF.Builder.CreateUnreachable(); } diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp index 5dcb3cdd05d02..95f6c35300a8b 100644 --- a/lib/IRGen/MetadataRequest.cpp +++ b/lib/IRGen/MetadataRequest.cpp @@ -1873,7 +1873,8 @@ MetadataResponse irgen::emitGenericTypeMetadataAccessFunction( IGM.Int8PtrTy, // arg 1 IGM.Int8PtrTy, // arg 2 IGM.TypeContextDescriptorPtrTy) // type context descriptor - .getCallee()); + .getCallee() + ->stripPointerCasts()); if (thunkFn->empty()) { ApplyIRLinkage(IRLinkage::InternalLinkOnceODR) @@ -2354,7 +2355,8 @@ emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type, IGM.getModule() ->getOrInsertFunction(instantiationFnName, IGF.IGM.TypeMetadataPtrTy, cache->getType()) - .getCallee()); + .getCallee() + ->stripPointerCasts()); if (instantiationFn->empty()) { ApplyIRLinkage(IRLinkage::InternalLinkOnceODR) .to(instantiationFn); diff --git a/lib/IRGen/TypeLayoutVerifier.cpp b/lib/IRGen/TypeLayoutVerifier.cpp index 0abd826005150..ae001b8f2e389 100644 --- a/lib/IRGen/TypeLayoutVerifier.cpp +++ b/lib/IRGen/TypeLayoutVerifier.cpp @@ -129,7 +129,7 @@ IRGenTypeVerifierFunction::emit(ArrayRef formalTypes) { Builder.CreateMemSet(xiBuf.getAddress(), llvm::ConstantInt::get(IGM.Int8Ty, 0x5A), fixedTI->getFixedSize().getValue(), - fixedTI->getFixedAlignment().getValue()); + llvm::MaybeAlign(fixedTI->getFixedAlignment().getValue())); // Ask the runtime to store an extra inhabitant. auto tag = llvm::ConstantInt::get(IGM.Int32Ty, i+1); diff --git a/lib/Immediate/REPL.cpp b/lib/Immediate/REPL.cpp index 42165afa9ea8e..6505f7dca2d3c 100644 --- a/lib/Immediate/REPL.cpp +++ b/lib/Immediate/REPL.cpp @@ -434,9 +434,8 @@ class REPLInput { PromptString.clear(); if (ShowColors) { - const char *colorCode = - llvm::sys::Process::OutputColor(llvm::raw_ostream::YELLOW, - false, false); + const char *colorCode = llvm::sys::Process::OutputColor( + static_cast(llvm::raw_ostream::YELLOW), false, false); if (colorCode) appendEscapeSequence(PromptString, colorCode); } diff --git a/lib/Index/IndexRecord.cpp b/lib/Index/IndexRecord.cpp index 6fe087b94f5bc..08367ca19c899 100644 --- a/lib/Index/IndexRecord.cpp +++ b/lib/Index/IndexRecord.cpp @@ -217,7 +217,7 @@ class StdlibGroupsIndexRecordingConsumer : public IndexDataConsumer { StringRef groupName = findGroupForSymbol(symbol); auto &tracker = TrackerByGroup[groupName]; if (!tracker) { - tracker = llvm::make_unique(); + tracker = std::make_unique(); } tracker->addOccurrence(symbol); return true; @@ -325,7 +325,7 @@ makeRecordingConsumer(std::string Filename, std::string indexStorePath, DiagnosticEngine *diags, std::string *outRecordFile, bool *outFailed) { - return llvm::make_unique([=](SymbolTracker &record) { + return std::make_unique([=](SymbolTracker &record) { *outFailed = writeRecord(record, Filename, indexStorePath, diags, *outRecordFile); }); @@ -357,7 +357,7 @@ class StringScratchSpace { public: const std::string *createString(StringRef str) { - StrsCreated.emplace_back(llvm::make_unique(str)); + StrsCreated.emplace_back(std::make_unique(str)); return StrsCreated.back().get(); } }; diff --git a/lib/LLVMPasses/LLVMInlineTree.cpp b/lib/LLVMPasses/LLVMInlineTree.cpp index 79a3502c85e23..f998f6d624c92 100644 --- a/lib/LLVMPasses/LLVMInlineTree.cpp +++ b/lib/LLVMPasses/LLVMInlineTree.cpp @@ -24,8 +24,9 @@ #include "llvm/IR/Function.h" #include "llvm/IR/DebugInfoMetadata.h" #include "llvm/Pass.h" -#include "llvm/Support/raw_ostream.h" +#include "llvm/Support/CommandLine.h" #include "llvm/Support/Format.h" +#include "llvm/Support/raw_ostream.h" #include "llvm/ADT/SmallSet.h" #include "swift/Demangling/Demangle.h" #include "swift/Basic/Range.h" diff --git a/lib/Migrator/Migrator.cpp b/lib/Migrator/Migrator.cpp index d2a7dfd10c34d..58bee5ab44379 100644 --- a/lib/Migrator/Migrator.cpp +++ b/lib/Migrator/Migrator.cpp @@ -146,7 +146,7 @@ Migrator::performAFixItMigration(version::Version SwiftLanguageVersion) { input.isPrimary() ? InputBuffer.get() : input.buffer())); } - auto Instance = llvm::make_unique(); + auto Instance = std::make_unique(); if (Instance->setup(Invocation)) { return nullptr; } @@ -185,7 +185,7 @@ bool Migrator::performSyntacticPasses(SyntacticPassOptions Opts) { new clang::DiagnosticIDs() }; auto ClangDiags = - llvm::make_unique(DummyClangDiagIDs, + std::make_unique(DummyClangDiagIDs, new clang::DiagnosticOptions, new clang::DiagnosticConsumer(), /*ShouldOwnClient=*/true); diff --git a/lib/ParseSIL/ParseSIL.cpp b/lib/ParseSIL/ParseSIL.cpp index 8050a926fe572..ca3b5f3e86f9c 100644 --- a/lib/ParseSIL/ParseSIL.cpp +++ b/lib/ParseSIL/ParseSIL.cpp @@ -103,7 +103,7 @@ SILParserTUState::~SILParserTUState() { } SILParserState::SILParserState(SILModule *M) - : Impl(M ? llvm::make_unique(*M) : nullptr) {} + : Impl(M ? std::make_unique(*M) : nullptr) {} SILParserState::~SILParserState() = default; diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp index 0486b0080fc09..d0d5157dc3e38 100644 --- a/lib/SILGen/SILGenType.cpp +++ b/lib/SILGen/SILGenType.cpp @@ -311,8 +311,14 @@ class SILGenVTable : public SILVTableVisitor { } void addPlaceholder(MissingMemberDecl *m) { - assert(m->getNumberOfVTableEntries() == 0 - && "Should not be emitting class with missing members"); +#ifndef NDEBUG + auto *classDecl = cast(m->getDeclContext()); + bool isResilient = + classDecl->isResilient(SGM.M.getSwiftModule(), + ResilienceExpansion::Maximal); + assert(isResilient || m->getNumberOfVTableEntries() == 0 && + "Should not be emitting fragile class with missing members"); +#endif } }; diff --git a/lib/SILOptimizer/Analysis/ClosureScope.cpp b/lib/SILOptimizer/Analysis/ClosureScope.cpp index 462075452413e..fbec6449a437c 100644 --- a/lib/SILOptimizer/Analysis/ClosureScope.cpp +++ b/lib/SILOptimizer/Analysis/ClosureScope.cpp @@ -159,7 +159,7 @@ void ClosureScopeAnalysis::notifyWillDeleteFunction(SILFunction *F) { ClosureScopeData *ClosureScopeAnalysis::getOrComputeScopeData() { if (!scopeData) { - scopeData = llvm::make_unique(); + scopeData = std::make_unique(); scopeData->compute(M); } return scopeData.get(); diff --git a/lib/SILOptimizer/Analysis/LoopAnalysis.cpp b/lib/SILOptimizer/Analysis/LoopAnalysis.cpp index 59ca2b4548114..d2c57723a297b 100644 --- a/lib/SILOptimizer/Analysis/LoopAnalysis.cpp +++ b/lib/SILOptimizer/Analysis/LoopAnalysis.cpp @@ -23,7 +23,7 @@ SILLoopAnalysis::newFunctionAnalysis(SILFunction *F) { assert(DA != nullptr && "Expect a valid dominance analysis"); DominanceInfo *DT = DA->get(F); assert(DT != nullptr && "Expect a valid dominance information"); - return llvm::make_unique(F, DT); + return std::make_unique(F, DT); } void SILLoopAnalysis::initialize(SILPassManager *PM) { diff --git a/lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp b/lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp index 117f1dd38ee0a..eb4b320fe2c9c 100644 --- a/lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp +++ b/lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp @@ -163,7 +163,7 @@ class COWArrayOpt { // Keep track of cold blocks. ColdBlockInfo ColdBlocks; - // Cache of the analysis whether a loop is safe wrt. make_unique hoisting by + // Cache of the analysis whether a loop is safe wrt.std::make_unique hoisting by // looking at the operations (no uniquely identified objects). std::pair CachedSafeLoop; @@ -627,7 +627,7 @@ bool COWArrayOpt::checkSafeElementValueUses(UserOperList &ElementValueUsers) { /// * all array semantic functions /// * stores to array elements /// * any instruction that does not have side effects. -/// * any retain must be matched by a release before we hit a make_unique. +/// * any retain must be matched by a release before we hit astd::make_unique. /// /// Note, that a release in this modus (we don't have a uniquely identified /// object) is not safe because the destructor of what we are releasing might diff --git a/lib/SILOptimizer/LoopTransforms/LICM.cpp b/lib/SILOptimizer/LoopTransforms/LICM.cpp index 53650a6bf37c8..efd423ced97f1 100644 --- a/lib/SILOptimizer/LoopTransforms/LICM.cpp +++ b/lib/SILOptimizer/LoopTransforms/LICM.cpp @@ -502,7 +502,7 @@ bool LoopTreeOptimization::optimize() { // Collect all summary of all sub loops of the current loop. Since we // process the loop tree bottom up they are guaranteed to be available in // the map. - auto CurrLoopSummary = llvm::make_unique(CurrentLoop); + auto CurrLoopSummary = std::make_unique(CurrentLoop); propagateSummaries(CurrLoopSummary); // If the current loop changed, then we might reveal more instr to hoist diff --git a/lib/SILOptimizer/Utils/ConstantFolding.cpp b/lib/SILOptimizer/Utils/ConstantFolding.cpp index af43e75cf71f2..af0d1c112e76e 100644 --- a/lib/SILOptimizer/Utils/ConstantFolding.cpp +++ b/lib/SILOptimizer/Utils/ConstantFolding.cpp @@ -23,6 +23,7 @@ #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/Statistic.h" +#include "llvm/IR/Intrinsics.h" #include "llvm/Support/Debug.h" #define DEBUG_TYPE "sil-constant-folding" @@ -288,9 +289,9 @@ constantFoldBinaryWithOverflow(BuiltinInst *BI, BuiltinValueKind ID, static SILValue constantFoldCountLeadingOrTrialingZeroIntrinsic(BuiltinInst *bi, bool countLeadingZeros) { - assert(bi->getIntrinsicID() == llvm::Intrinsic::ctlz || - bi->getIntrinsicID() == llvm::Intrinsic::cttz && - "Invalid Intrinsic - expected Ctlz/Cllz"); + assert((bi->getIntrinsicID() == (llvm::Intrinsic::ID)llvm::Intrinsic::ctlz || + bi->getIntrinsicID() == (llvm::Intrinsic::ID)llvm::Intrinsic::cttz) && + "Invalid Intrinsic - expected Ctlz/Cllz"); OperandValueArrayRef args = bi->getArguments(); // Fold for integer constant arguments. diff --git a/lib/SILOptimizer/Utils/OptimizerStatsUtils.cpp b/lib/SILOptimizer/Utils/OptimizerStatsUtils.cpp index cd7c273499bef..6029702cc1073 100644 --- a/lib/SILOptimizer/Utils/OptimizerStatsUtils.cpp +++ b/lib/SILOptimizer/Utils/OptimizerStatsUtils.cpp @@ -514,7 +514,7 @@ class OptimizerStatsAnalysis : public SILAnalysis { /// Get the collected statistics for a function. FunctionStat &getFunctionStat(const SILFunction *F) { if (!Cache) - Cache = llvm::make_unique(); + Cache = std::make_unique(); return Cache->getFunctionStat(F); } @@ -522,7 +522,7 @@ class OptimizerStatsAnalysis : public SILAnalysis { /// Get the collected statistics for a module. ModuleStat &getModuleStat() { if (!Cache) - Cache = llvm::make_unique(); + Cache = std::make_unique(); return Cache->getModuleStat(); } @@ -557,7 +557,7 @@ llvm::raw_ostream &stats_os() { if (!SILStatsOutputFile.empty()) { // Try to open the file. std::error_code EC; - auto fd_stream = llvm::make_unique( + auto fd_stream = std::make_unique( SILStatsOutputFile, EC, llvm::sys::fs::OpenFlags::F_Text); if (!fd_stream->has_error() && !EC) { stats_output_stream = {fd_stream.release(), diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp index 8982a62545e44..b46e4dd281c65 100644 --- a/lib/Sema/CSDiag.cpp +++ b/lib/Sema/CSDiag.cpp @@ -182,12 +182,6 @@ class FailureDiagnosis :public ASTVisitor{ return type; } - /// Diagnose common failures due to applications of an argument list to an - /// ApplyExpr or SubscriptExpr. - bool diagnoseParameterErrors(CalleeCandidateInfo &CCI, - Expr *fnExpr, Expr *argExpr, - ArrayRef argLabels); - /// Attempt to diagnose a specific failure from the info we've collected from /// the failed constraint system. bool diagnoseExprFailure(); @@ -918,48 +912,6 @@ static Expr *getFailedArgumentExpr(CalleeCandidateInfo CCI, Expr *argExpr) { } } -/// If the candidate set has been narrowed down to a specific structural -/// problem, e.g. that there are too few parameters specified or that argument -/// labels don't match up, diagnose that error and return true. -bool FailureDiagnosis::diagnoseParameterErrors(CalleeCandidateInfo &CCI, - Expr *fnExpr, Expr *argExpr, - ArrayRef argLabels) { - // If we have a failure where the candidate set differs on exactly one - // argument, and where we have a consistent mismatch across the candidate set - // (often because there is only one candidate in the set), then diagnose this - // as a specific problem of passing something of the wrong type into a - // parameter. - // - // We don't generally want to use this path to diagnose calls to - // symmetrically-typed binary operators because it's likely that both - // operands contributed to the type. - if ((CCI.closeness == CC_OneArgumentMismatch || - CCI.closeness == CC_OneArgumentNearMismatch || - CCI.closeness == CC_OneGenericArgumentMismatch || - CCI.closeness == CC_OneGenericArgumentNearMismatch || - CCI.closeness == CC_GenericNonsubstitutableMismatch) && - CCI.failedArgument.isValid() && - !isSymmetricBinaryOperator(CCI)) { - // Map the argument number into an argument expression. - TCCOptions options = TCC_ForceRecheck; - if (CCI.failedArgument.parameterType->is()) - options |= TCC_AllowLValue; - - // It could be that the argument doesn't conform to an archetype. - Expr *badArgExpr = getFailedArgumentExpr(CCI, argExpr); - - // Re-type-check the argument with the expected type of the candidate set. - // This should produce a specific and tailored diagnostic saying that the - // type mismatches with expectations. - Type paramType = CCI.failedArgument.parameterType; - if (!typeCheckChildIndependently(badArgExpr, paramType, - CTP_CallArgument, options)) - return true; - } - - return false; -} - bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) { auto *fnExpr = callExpr->getFn(); auto fnType = CS.getType(fnExpr)->getRValueType(); @@ -997,9 +949,6 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) { SmallVector argLabelsScratch; ArrayRef argLabels = callExpr->getArgumentLabels(argLabelsScratch); - if (diagnoseParameterErrors(calleeInfo, callExpr->getFn(), - callExpr->getArg(), argLabels)) - return true; Type argType; // argument list, if known. if (auto FTy = fnType->getAs()) { @@ -1025,10 +974,6 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) { calleeInfo.filterListArgs(decomposeArgType(CS.getType(argExpr), argLabels)); - if (diagnoseParameterErrors(calleeInfo, callExpr->getFn(), argExpr, - argLabels)) - return true; - // Force recheck of the arg expression because we allowed unresolved types // before, and that turned out not to help, and now we want any diagnoses // from disallowing them. diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp index cfecbcb68ec2a..f853f146d9919 100644 --- a/lib/Sema/CSDiagnostics.cpp +++ b/lib/Sema/CSDiagnostics.cpp @@ -4792,6 +4792,23 @@ bool InvalidUseOfAddressOf::diagnoseAsError() { bool ExtraneousReturnFailure::diagnoseAsError() { auto *anchor = getAnchor(); emitDiagnostic(anchor->getLoc(), diag::cannot_return_value_from_void_func); + if (auto FD = dyn_cast(getDC())) { + // We only want to emit the note + fix-it if the function does not + // have an explicit return type. The reason we also need to check + // whether the parameter list has a valid loc is to guard against + // cases like like 'var foo: () { return 1 }' as here that loc will + // be invalid. We also need to check that the name is not empty, + // because certain decls will have empty name (like setters). + if (FD->getBodyResultTypeLoc().getLoc().isInvalid() && + FD->getParameters()->getStartLoc().isValid() && + !FD->getName().empty()) { + auto fixItLoc = Lexer::getLocForEndOfToken( + getASTContext().SourceMgr, FD->getParameters()->getEndLoc()); + emitDiagnostic(anchor->getLoc(), diag::add_return_type_note) + .fixItInsert(fixItLoc, " -> <#Return Type#>"); + } + } + return true; } diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp index bd756f48d479a..f93b4adc66bc5 100644 --- a/lib/Sema/CSSimplify.cpp +++ b/lib/Sema/CSSimplify.cpp @@ -3072,23 +3072,16 @@ bool ConstraintSystem::repairFailures( auto elt = path.back(); switch (elt.getKind()) { case ConstraintLocator::LValueConversion: { - auto CTP = getContextualTypePurpose(anchor); - // Special case for `CTP_CallArgument` set by CSDiag - // while type-checking each argument because we yet - // to cover argument-to-parameter conversions in the - // new framework. - if (CTP != CTP_CallArgument) { - // Ignore l-value conversion element since it has already - // played its role. - path.pop_back(); - // If this is a contextual mismatch between l-value types e.g. - // `@lvalue String vs. @lvalue Int`, let's pretend that it's okay. - if (!path.empty() && path.back().is()) { - auto *locator = getConstraintLocator(anchor, path.back()); - conversionsOrFixes.push_back( - IgnoreContextualType::create(*this, lhs, rhs, locator)); - break; - } + // Ignore l-value conversion element since it has already + // played its role. + path.pop_back(); + // If this is a contextual mismatch between l-value types e.g. + // `@lvalue String vs. @lvalue Int`, let's pretend that it's okay. + if (!path.empty() && path.back().is()) { + auto *locator = getConstraintLocator(anchor, path.back()); + conversionsOrFixes.push_back( + IgnoreContextualType::create(*this, lhs, rhs, locator)); + break; } LLVM_FALLTHROUGH; @@ -3521,13 +3514,6 @@ bool ConstraintSystem::repairFailures( if (rhs->isExistentialType()) break; - // TODO(diagnostics): This is a problem related to `inout` mismatch, - // in argument position, and we got here from CSDiag. Once - // argument-to-pararameter conversion failures are implemented, - // this check could be removed. - if (lhs->is() || rhs->is()) - break; - if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes, locator)) break; diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp index 6e0fad21db1de..33b09fe21a6ac 100644 --- a/lib/Sema/CSSolver.cpp +++ b/lib/Sema/CSSolver.cpp @@ -421,6 +421,7 @@ ConstraintSystem::SolverState::~SolverState() { #define CS_STATISTIC(Name, Description) JOIN2(Overall,Name) += Name; #include "ConstraintSolverStats.def" +#if LLVM_ENABLE_STATS // Update the "largest" statistics if this system is larger than the // previous one. // FIXME: This is not at all thread-safe. @@ -432,6 +433,7 @@ ConstraintSystem::SolverState::~SolverState() { ++JOIN2(Largest,Name); #include "ConstraintSolverStats.def" } +#endif } ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs) @@ -1330,7 +1332,7 @@ void ConstraintSystem::solveImpl(SmallVectorImpl &solutions) { SmallVector, 16> workList; // First step is always wraps whole constraint system. - workList.push_back(llvm::make_unique(*this, solutions)); + workList.push_back(std::make_unique(*this, solutions)); // Indicate whether previous step in the stack has failed // (returned StepResult::Kind = Error), this is useful to diff --git a/lib/Sema/CSStep.cpp b/lib/Sema/CSStep.cpp index 59afc3ae0d0d2..6ae08628df958 100644 --- a/lib/Sema/CSStep.cpp +++ b/lib/Sema/CSStep.cpp @@ -95,7 +95,7 @@ void SplitterStep::computeFollowupSteps( auto components = CG.computeConnectedComponents(CS.getTypeVariables()); unsigned numComponents = components.size(); if (numComponents < 2) { - steps.push_back(llvm::make_unique( + steps.push_back(std::make_unique( CS, 0, &CS.InactiveConstraints, Solutions)); return; } @@ -126,7 +126,7 @@ void SplitterStep::computeFollowupSteps( // If there are no dependencies, build a normal component step. if (components[i].dependsOn.empty()) { - steps.push_back(llvm::make_unique( + steps.push_back(std::make_unique( CS, solutionIndex, &Components[i], std::move(components[i]), PartialSolutions[solutionIndex])); continue; @@ -141,7 +141,7 @@ void SplitterStep::computeFollowupSteps( // Otherwise, build a dependent component "splitter" step, which // handles all combinations of incoming partial solutions. - steps.push_back(llvm::make_unique( + steps.push_back(std::make_unique( CS, &Components[i], solutionIndex, std::move(components[i]), llvm::makeMutableArrayRef(PartialSolutions.get(), numComponents))); } @@ -273,7 +273,7 @@ StepResult DependentComponentSplitterStep::take(bool prevFailed) { } followup.push_back( - llvm::make_unique(CS, Index, Constraints, Component, + std::make_unique(CS, Index, Constraints, Component, std::move(dependsOnSolutions), Solutions)); } while (nextCombination(dependsOnSetsRef, indices)); @@ -333,11 +333,11 @@ StepResult ComponentStep::take(bool prevFailed) { (!disjunction || bestBindings->favoredOverDisjunction(disjunction))) { // Produce a type variable step. return suspend( - llvm::make_unique(CS, *bestBindings, Solutions)); + std::make_unique(CS, *bestBindings, Solutions)); } else if (disjunction) { // Produce a disjunction step. return suspend( - llvm::make_unique(CS, disjunction, Solutions)); + std::make_unique(CS, disjunction, Solutions)); } else if (!CS.solverState->allowsFreeTypeVariables() && CS.hasFreeTypeVariables()) { // If there are no disjunctions or type variables to bind diff --git a/lib/Sema/CSStep.h b/lib/Sema/CSStep.h index 77c54766348c2..221e2a0c01396 100644 --- a/lib/Sema/CSStep.h +++ b/lib/Sema/CSStep.h @@ -475,7 +475,7 @@ class ComponentStep final : public SolverStep { if (isDebugMode()) getDebugLogger() << "(solving component #" << Index << '\n'; - ComponentScope = llvm::make_unique(*this); + ComponentScope = std::make_unique(*this); // If this component has orphaned constraint attached, // let's return it to the graph. @@ -524,10 +524,10 @@ template class BindingStep : public SolverStep { } { - auto scope = llvm::make_unique(CS); + auto scope = std::make_unique(CS); if (attempt(*choice)) { ActiveChoice.emplace(std::move(scope), *choice); - return suspend(llvm::make_unique(CS, Solutions)); + return suspend(std::make_unique(CS, Solutions)); } } diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp index 11358c3bd4e46..531f51cdb9916 100644 --- a/lib/Sema/ConstraintSystem.cpp +++ b/lib/Sema/ConstraintSystem.cpp @@ -2765,6 +2765,9 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes( ParameterList, /// General ambiguity failure. General, + /// Argument mismatch ambiguity where each solution has the same + /// argument mismatch fixes for the same call. + ArgumentMismatch }; auto ambiguityKind = AmbiguityKind::CloseMatch; @@ -2775,16 +2778,52 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes( return false; if (fixes.size() > 1) { - ambiguityKind = (ambiguityKind == AmbiguityKind::CloseMatch || - ambiguityKind == AmbiguityKind::ParameterList) && + // Attempt to disambiguite in cases where the argument matches + // involves tuple mismatches. e.g. + // func t(_: (T, U), _: (U, T)) {} + // func useTuples(_ x: Int, y: Float) { + // t((x, y), (x, y)) + // } + // So fixes are ambiguous in all solutions. + if ((ambiguityKind == AmbiguityKind::CloseMatch || + ambiguityKind == AmbiguityKind::ArgumentMismatch) && llvm::all_of(fixes, [](const ConstraintFix *fix) -> bool { - auto *locator = fix->getLocator(); - return locator->findLast().hasValue(); - }) ? AmbiguityKind::ParameterList - : AmbiguityKind::General; + return fix->getKind() == FixKind::AllowTupleTypeMismatch; + })) { + ambiguityKind = AmbiguityKind::ArgumentMismatch; + } else { + ambiguityKind = + (ambiguityKind == AmbiguityKind::CloseMatch || + ambiguityKind == AmbiguityKind::ArgumentMismatch || + ambiguityKind == AmbiguityKind::ParameterList) && + llvm::all_of( + fixes, + [](const ConstraintFix *fix) -> bool { + auto *locator = fix->getLocator(); + return locator + ->findLast() + .hasValue(); + }) + ? AmbiguityKind::ParameterList + : AmbiguityKind::General; + } + } + + if (fixes.size() == 1) { + // Attempt to disambiguite in cases where all the solutions + // produces the same fixes for different generic arguments e.g. + // func f(_: T, _: T) {} + // f(Int(1), Float(1)) + // + ambiguityKind = + ((ambiguityKind == AmbiguityKind::CloseMatch || + ambiguityKind == AmbiguityKind::ArgumentMismatch) && + fixes.front()->getKind() == FixKind::AllowArgumentTypeMismatch) + ? AmbiguityKind::ArgumentMismatch + : AmbiguityKind::CloseMatch; } - for (const auto *fix: fixes) { + for (const auto *fix : fixes) { auto *locator = fix->getLocator(); // Assignment failures are all about the source expression, // because they treat destination as a contextual type. @@ -2816,6 +2855,15 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes( return true; }); + if (ambiguityKind == AmbiguityKind::ArgumentMismatch && + viableSolutions.size() == 1) { + // Let's apply the solution so the contextual generic types + // are available in the system for diagnostics. + applySolution(*viableSolutions[0]); + solutions.front().Fixes.front()->diagnose(/*asNote*/ false); + return true; + } + if (!diagnosable || viableSolutions.size() < 2) return false; @@ -2860,6 +2908,7 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes( }; switch (ambiguityKind) { + case AmbiguityKind::ArgumentMismatch: case AmbiguityKind::CloseMatch: // Handled below break; diff --git a/lib/Sema/TypeCheckDecl.h b/lib/Sema/TypeCheckDecl.h index 1bfd954260cdf..9ff2e086998f7 100644 --- a/lib/Sema/TypeCheckDecl.h +++ b/lib/Sema/TypeCheckDecl.h @@ -63,4 +63,3 @@ bool checkDesignatedTypes(OperatorDecl *OD, } #endif - diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h index ffd1186ca73e2..72467a227c39d 100644 --- a/lib/Serialization/ModuleFormat.h +++ b/lib/Serialization/ModuleFormat.h @@ -55,7 +55,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0; /// describe what change you made. The content of this comment isn't important; /// it just ensures a conflict if two people change the module format. /// Don't worry about adhering to the 80-column limit for this line. -const uint16_t SWIFTMODULE_VERSION_MINOR = 538; // swiftmodules from swiftinterfaces have nested types tables +const uint16_t SWIFTMODULE_VERSION_MINOR = 539; // swift master-rebranch /// A standard hash seed used for all string hashes in a serialized module. /// diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp index 9dcf19486acf9..fb8fa9905d35c 100644 --- a/lib/Serialization/Serialization.cpp +++ b/lib/Serialization/Serialization.cpp @@ -2583,7 +2583,7 @@ class Serializer::DeclSerializer : public DeclVisitor { std::unique_ptr &memberTable = S.DeclMemberNames[VD->getBaseName()].second; if (!memberTable) { - memberTable = llvm::make_unique(); + memberTable = std::make_unique(); } (*memberTable)[parentID].push_back(memberID); } @@ -2593,7 +2593,7 @@ class Serializer::DeclSerializer : public DeclVisitor { std::unique_ptr &memberTable = S.DeclMemberNames[A->getMemberName().getBaseName()].second; if (!memberTable) { - memberTable = llvm::make_unique(); + memberTable = std::make_unique(); } (*memberTable)[parentID].push_back(memberID); } @@ -5070,7 +5070,7 @@ void swift::serializeToBuffers( if (hadError) return; if (moduleBuffer) - *moduleBuffer = llvm::make_unique( + *moduleBuffer = std::make_unique( std::move(buf), options.OutputPath); } @@ -5087,7 +5087,7 @@ void swift::serializeToBuffers( return false; }); if (moduleDocBuffer) - *moduleDocBuffer = llvm::make_unique( + *moduleDocBuffer = std::make_unique( std::move(buf), options.DocOutputPath); } @@ -5104,8 +5104,8 @@ void swift::serializeToBuffers( return false; }); if (moduleSourceInfoBuffer) - *moduleSourceInfoBuffer = llvm::make_unique( - std::move(buf), options.SourceInfoOutputPath); + *moduleSourceInfoBuffer = std::make_unique( + std::move(buf), options.SourceInfoOutputPath); } } diff --git a/stdlib/public/Reflection/TypeRef.cpp b/stdlib/public/Reflection/TypeRef.cpp index 3503dd1e79e91..154f5837571b7 100644 --- a/stdlib/public/Reflection/TypeRef.cpp +++ b/stdlib/public/Reflection/TypeRef.cpp @@ -376,6 +376,295 @@ void TypeRef::dump(FILE *file, unsigned Indent) const { fprintf(file, "\n"); } +class DemanglingForTypeRef + : public TypeRefVisitor { + Demangle::Demangler &Dem; + +public: + DemanglingForTypeRef(Demangle::Demangler &Dem) : Dem(Dem) {} + + Demangle::NodePointer visitBuiltinTypeRef(const BuiltinTypeRef *B) { + return Dem.demangleType(B->getMangledName()); + } + + Demangle::NodePointer visitNominalTypeRef(const NominalTypeRef *N) { + if (auto parent = N->getParent()) + assert(false && "not implemented"); + return Dem.demangleType(N->getMangledName()); + } + + Demangle::NodePointer + visitBoundGenericTypeRef(const BoundGenericTypeRef *BG) { + Node::Kind nodeKind; + Node::Kind genericNodeKind; + if (BG->isStruct()) { + nodeKind = Node::Kind::Structure; + genericNodeKind = Node::Kind::BoundGenericStructure; + } else if (BG->isEnum()) { + nodeKind = Node::Kind::Enum; + genericNodeKind = Node::Kind::BoundGenericEnum; + } else if (BG->isClass()) { + nodeKind = Node::Kind::Class; + genericNodeKind = Node::Kind::BoundGenericClass; + } else { + nodeKind = Node::Kind::OtherNominalType; + genericNodeKind = Node::Kind::BoundGenericOtherNominalType; + } + auto unspecializedType = Dem.demangleType(BG->getMangledName()); + + auto genericArgsList = Dem.createNode(Node::Kind::TypeList); + for (auto param : BG->getGenericParams()) + genericArgsList->addChild(visit(param), Dem); + + auto genericNode = Dem.createNode(genericNodeKind); + genericNode->addChild(unspecializedType, Dem); + genericNode->addChild(genericArgsList, Dem); + + if (auto parent = BG->getParent()) + assert(false && "not implemented"); + + auto top = Dem.createNode(Node::Kind::Type); + top->addChild(genericNode, Dem); + return top; + } + + Demangle::NodePointer visitTupleTypeRef(const TupleTypeRef *T) { + auto tuple = Dem.createNode(Node::Kind::Tuple); + if (T->isVariadic()) { + auto tupleElt = Dem.createNode(Node::Kind::TupleElement); + tupleElt->addChild(Dem.createNode(Node::Kind::VariadicMarker), Dem); + tuple->addChild(tupleElt, Dem); + return tuple; + } + + for (auto element : T->getElements()) { + auto tupleElt = Dem.createNode(Node::Kind::TupleElement); + tupleElt->addChild(visit(element), Dem); + tuple->addChild(tupleElt, Dem); + } + return tuple; + } + + Demangle::NodePointer visitFunctionTypeRef(const FunctionTypeRef *F) { + Node::Kind kind; + switch (F->getFlags().getConvention()) { + case FunctionMetadataConvention::Swift: + kind = !F->getFlags().isEscaping() ? Node::Kind::NoEscapeFunctionType + : Node::Kind::FunctionType; + break; + case FunctionMetadataConvention::Block: + kind = Node::Kind::ObjCBlock; + break; + case FunctionMetadataConvention::Thin: + kind = Node::Kind::ThinFunctionType; + break; + case FunctionMetadataConvention::CFunctionPointer: + kind = Node::Kind::CFunctionPointer; + break; + } + + SmallVector, 8> inputs; + for (const auto ¶m : F->getParameters()) { + auto flags = param.getFlags(); + auto input = visit(param.getType()); + + auto wrapInput = [&](Node::Kind kind) { + auto parent = Dem.createNode(kind); + parent->addChild(input, Dem); + input = parent; + }; + switch (flags.getValueOwnership()) { + case ValueOwnership::Default: + /* nothing */ + break; + case ValueOwnership::InOut: + wrapInput(Node::Kind::InOut); + break; + case ValueOwnership::Shared: + wrapInput(Node::Kind::Shared); + break; + case ValueOwnership::Owned: + wrapInput(Node::Kind::Owned); + break; + } + + inputs.push_back({input, flags.isVariadic()}); + } + NodePointer totalInput = nullptr; + // FIXME: this is copy&paste from Demangle.cpp + switch (inputs.size()) { + case 1: { + auto singleParam = inputs.front(); + + // If the sole unlabeled parameter has a non-tuple type, encode + // the parameter list as a single type. + if (!singleParam.second) { + auto singleType = singleParam.first; + if (singleType->getKind() == Node::Kind::Type) + singleType = singleType->getFirstChild(); + if (singleType->getKind() != Node::Kind::Tuple) { + totalInput = singleParam.first; + break; + } + } + + // Otherwise it requires a tuple wrapper. + LLVM_FALLTHROUGH; + } + + // This covers both none and multiple parameters. + default: + auto tuple = Dem.createNode(Node::Kind::Tuple); + for (auto &input : inputs) { + NodePointer eltType; + bool isVariadic; + std::tie(eltType, isVariadic) = input; + + // Tuple element := variadic-marker label? type + auto tupleElt = Dem.createNode(Node::Kind::TupleElement); + + if (isVariadic) + tupleElt->addChild(Dem.createNode(Node::Kind::VariadicMarker), Dem); + + if (eltType->getKind() == Node::Kind::Type) { + tupleElt->addChild(eltType, Dem); + } else { + auto type = Dem.createNode(Node::Kind::Type); + type->addChild(eltType, Dem); + tupleElt->addChild(type, Dem); + } + + tuple->addChild(tupleElt, Dem); + } + totalInput = tuple; + break; + } + + NodePointer parameters = Dem.createNode(Node::Kind::ArgumentTuple); + NodePointer paramType = Dem.createNode(Node::Kind::Type); + + paramType->addChild(totalInput, Dem); + parameters->addChild(paramType, Dem); + + NodePointer resultTy = visit(F->getResult()); + NodePointer result = Dem.createNode(Node::Kind::ReturnType); + result->addChild(resultTy, Dem); + + auto funcNode = Dem.createNode(kind); + if (F->getFlags().throws()) + funcNode->addChild(Dem.createNode(Node::Kind::ThrowsAnnotation), Dem); + funcNode->addChild(parameters, Dem); + funcNode->addChild(result, Dem); + return funcNode; + } + + Demangle::NodePointer + visitProtocolCompositionTypeRef(const ProtocolCompositionTypeRef *PC) { + auto type_list = Dem.createNode(Node::Kind::TypeList); + for (auto protocol : PC->getProtocols()) + type_list->addChild(visit(protocol), Dem); + + auto proto_list = Dem.createNode(Node::Kind::ProtocolList); + proto_list->addChild(type_list, Dem); + + auto node = proto_list; + if (auto superclass = PC->getSuperclass()) { + node = Dem.createNode(Node::Kind::ProtocolListWithClass); + node->addChild(proto_list, Dem); + node->addChild(visit(superclass), Dem); + } else if (PC->hasExplicitAnyObject()) { + node = Dem.createNode(Node::Kind::ProtocolListWithAnyObject); + node->addChild(proto_list, Dem); + } + auto typeNode = Dem.createNode(Node::Kind::Type); + typeNode->addChild(node, Dem); + return typeNode; + } + + Demangle::NodePointer visitMetatypeTypeRef(const MetatypeTypeRef *M) { + auto node = Dem.createNode(Node::Kind::Metatype); + assert(!M->wasAbstract() && "not implemented"); + node->addChild(visit(M->getInstanceType()), Dem); + auto typeNode = Dem.createNode(Node::Kind::Type); + typeNode->addChild(node, Dem); + return typeNode; + } + + Demangle::NodePointer + visitExistentialMetatypeTypeRef(const ExistentialMetatypeTypeRef *EM) { + auto node = Dem.createNode(Node::Kind::Metatype); + node->addChild(visit(EM->getInstanceType()), Dem); + return node; + } + + Demangle::NodePointer + visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) { + assert(false && "not tested"); + auto node = Dem.createNode(Node::Kind::DependentGenericParamType); + node->addChild(Dem.createNode(Node::Kind::Index, GTP->getDepth()), Dem); + node->addChild(Dem.createNode(Node::Kind::Index, GTP->getIndex()), Dem); + return node; + } + + Demangle::NodePointer + visitDependentMemberTypeRef(const DependentMemberTypeRef *DM) { + assert(false && "not tested"); + assert(DM->getProtocol().empty() && "not implemented"); + auto node = Dem.createNode(Node::Kind::DependentMemberType); + node->addChild(visit(DM->getBase()), Dem); + node->addChild(Dem.createNode(Node::Kind::Identifier, DM->getMember()), + Dem); + return node; + } + + Demangle::NodePointer visitForeignClassTypeRef(const ForeignClassTypeRef *F) { + assert(false && "not implemented"); + return nullptr; + } + + Demangle::NodePointer visitObjCClassTypeRef(const ObjCClassTypeRef *OC) { + auto module = Dem.createNode(Node::Kind::Module, MANGLING_MODULE_OBJC); + auto node = Dem.createNode(Node::Kind::Class); + node->addChild(module, Dem); + node->addChild(Dem.createNode(Node::Kind::Identifier, OC->getName()), Dem); + return node; + } + + Demangle::NodePointer + visitObjCProtocolTypeRef(const ObjCProtocolTypeRef *OC) { + auto module = Dem.createNode(Node::Kind::Module, MANGLING_MODULE_OBJC); + auto node = Dem.createNode(Node::Kind::Protocol); + node->addChild(module, Dem); + node->addChild(Dem.createNode(Node::Kind::Identifier, OC->getName()), Dem); + auto typeNode = Dem.createNode(Node::Kind::Type); + typeNode->addChild(node, Dem); + return typeNode; + } + +#define REF_STORAGE(Name, name, ...) \ + Demangle::NodePointer visit##Name##StorageTypeRef( \ + const Name##StorageTypeRef *US) { \ + auto node = Dem.createNode(Node::Kind::Name); \ + node->addChild(visit(US->getType()), Dem); \ + return node; \ + } +#include "swift/AST/ReferenceStorage.def" + + Demangle::NodePointer visitSILBoxTypeRef(const SILBoxTypeRef *SB) { + auto node = Dem.createNode(Node::Kind::SILBoxType); + node->addChild(visit(SB->getBoxedType()), Dem); + return node; + } + + Demangle::NodePointer visitOpaqueTypeRef(const OpaqueTypeRef *O) { + return Dem.createNode(Node::Kind::OpaqueType); + } +}; + +Demangle::NodePointer TypeRef::getDemangling(Demangle::Demangler &Dem) const { + return DemanglingForTypeRef(Dem).visit(this); +} + bool TypeRef::isConcrete() const { GenericArgumentMap Subs; return TypeRefIsConcrete(Subs).visit(this); diff --git a/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp b/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp index 9cfda37a6c4b9..c73d7194e101c 100644 --- a/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp +++ b/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp @@ -19,6 +19,7 @@ SWIFT_REMOTE_MIRROR_LINKAGE unsigned long long swift_reflection_classIsSwiftMask = 2; } +#include "swift/Demangling/Demangler.h" #include "swift/Reflection/ReflectionContext.h" #include "swift/Reflection/TypeLowering.h" #include "swift/Remote/CMemoryReader.h" @@ -431,6 +432,17 @@ void swift_reflection_dumpInfoForTypeRef(SwiftReflectionContextRef ContextRef, fprintf(stdout, "\n"); } else { TI->dump(stdout); + Demangle::Demangler Dem; + std::string MangledName = mangleNode(TR->getDemangling(Dem)); + fprintf(stdout, "Mangled name: %s%s\n", MANGLING_PREFIX_STR, + MangledName.c_str()); +#ifndef NDEBUG + auto *Reconstructed = reinterpret_cast( + swift_reflection_typeRefForMangledTypeName( + ContextRef, MangledName.c_str(), MangledName.size())); + assert(mangleNode(TR->getDemangling(Dem)) == MangledName && + "round-trip diff"); +#endif } } diff --git a/stdlib/public/runtime/Demangle.cpp b/stdlib/public/runtime/Demangle.cpp index c71bc385613f5..f082e47e015aa 100644 --- a/stdlib/public/runtime/Demangle.cpp +++ b/stdlib/public/runtime/Demangle.cpp @@ -10,12 +10,13 @@ // //===----------------------------------------------------------------------===// -#include "swift/Basic/Range.h" +#include "Private.h" #include "swift/ABI/TypeIdentity.h" +#include "swift/Basic/Range.h" +#include "swift/Reflection/TypeRef.h" #include "swift/Runtime/Metadata.h" #include "swift/Runtime/Portability.h" #include "swift/Strings.h" -#include "Private.h" #include diff --git a/stdlib/public/runtime/Errors.cpp b/stdlib/public/runtime/Errors.cpp index 6e202434750f0..12af02d9882f2 100644 --- a/stdlib/public/runtime/Errors.cpp +++ b/stdlib/public/runtime/Errors.cpp @@ -24,6 +24,7 @@ #include #endif +#include #include #include #include diff --git a/test/ClangImporter/Inputs/custom-modules/CoreCooling.h b/test/ClangImporter/Inputs/custom-modules/CoreCooling.h index 84e9345229428..7abd92cc9f573 100644 --- a/test/ClangImporter/Inputs/custom-modules/CoreCooling.h +++ b/test/ClangImporter/Inputs/custom-modules/CoreCooling.h @@ -65,4 +65,4 @@ typedef struct IceCube { } IceCube; typedef IceCube IceCube; -typedef IceCube BlockOfIce; \ No newline at end of file +typedef IceCube BlockOfIce; diff --git a/test/ClangImporter/Inputs/custom-modules/RedeclaredErrorEnum/Redeclared.h b/test/ClangImporter/Inputs/custom-modules/RedeclaredErrorEnum/Redeclared.h index ae66a21863fc7..aad1675a85558 100644 --- a/test/ClangImporter/Inputs/custom-modules/RedeclaredErrorEnum/Redeclared.h +++ b/test/ClangImporter/Inputs/custom-modules/RedeclaredErrorEnum/Redeclared.h @@ -13,4 +13,4 @@ enum __attribute__((ns_error_domain(SomeErrorDomain))) SomeErrorCode : long SomeErrorY } #endif -; \ No newline at end of file +; diff --git a/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/Headers/PrivateAsParallel.h b/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/Headers/PrivateAsParallel.h index eaa826951e9d6..6fb126ab48078 100644 --- a/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/Headers/PrivateAsParallel.h +++ b/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/Headers/PrivateAsParallel.h @@ -1 +1 @@ -extern int PPGlobal; \ No newline at end of file +extern int PPGlobal; diff --git a/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/PrivateHeaders/PrivateAsParallel_Priv.h b/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/PrivateHeaders/PrivateAsParallel_Priv.h index 2c8cd4d5efae9..5d3addb39f430 100644 --- a/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/PrivateHeaders/PrivateAsParallel_Priv.h +++ b/test/ClangImporter/Inputs/frameworks/PrivateAsParallel.framework/PrivateHeaders/PrivateAsParallel_Priv.h @@ -1,2 +1,2 @@ #include -extern int PPPrivateGlobal; \ No newline at end of file +extern int PPPrivateGlobal; diff --git a/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/Headers/PrivateAsSubmodule.h b/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/Headers/PrivateAsSubmodule.h index 2b6063190794c..ccfa15bbb646a 100644 --- a/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/Headers/PrivateAsSubmodule.h +++ b/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/Headers/PrivateAsSubmodule.h @@ -1 +1 @@ -extern int PSGlobal; \ No newline at end of file +extern int PSGlobal; diff --git a/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/PrivateHeaders/PrivateAsSubmodule_Priv.h b/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/PrivateHeaders/PrivateAsSubmodule_Priv.h index 346c419d56279..ec4785cb1fd79 100644 --- a/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/PrivateHeaders/PrivateAsSubmodule_Priv.h +++ b/test/ClangImporter/Inputs/frameworks/PrivateAsSubmodule.framework/PrivateHeaders/PrivateAsSubmodule_Priv.h @@ -1,2 +1,2 @@ #include -extern int PSPrivateGlobal; \ No newline at end of file +extern int PSPrivateGlobal; diff --git a/test/ClangImporter/ctypes_ir.swift b/test/ClangImporter/ctypes_ir.swift index 73d313f2b4e60..b0a6383bb1608 100644 --- a/test/ClangImporter/ctypes_ir.swift +++ b/test/ClangImporter/ctypes_ir.swift @@ -27,7 +27,7 @@ func testStructWithFlexibleArray(_ s : StructWithFlexibleArray) { } // Make sure flexible array struct member isn't represented in IR function signature as i0 (or at all). rdar://problem/18510461 -// CHECK-LABEL: define hidden swiftcc void @"$s9ctypes_ir27testStructWithFlexibleArrayyySo0defG0aF"(i32) +// CHECK-LABEL: define hidden swiftcc void @"$s9ctypes_ir27testStructWithFlexibleArrayyySo0defG0aF"(i32 %0) typealias EightUp = (Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8) diff --git a/test/ClangImporter/cxx_interop_ir.swift b/test/ClangImporter/cxx_interop_ir.swift index 59d7a075d6799..97b3d229bc9b7 100644 --- a/test/ClangImporter/cxx_interop_ir.swift +++ b/test/ClangImporter/cxx_interop_ir.swift @@ -30,7 +30,7 @@ func accessNSMember() { useT(ns.doMakeT()) } -// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir12basicMethods1as5Int32VSpySo0D0VG_tF"(i8*) +// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir12basicMethods1as5Int32VSpySo0D0VG_tF"(i8* %0) // CHECK: [[THIS_PTR1:%.*]] = bitcast i8* %0 to %TSo7MethodsV* // CHECK: [[THIS_PTR2:%.*]] = bitcast %TSo7MethodsV* [[THIS_PTR1]] to %class.Methods* // CHECK: [[RESULT:%.*]] = call {{(signext )?}}i32 @{{_ZN7Methods12SimpleMethodEi|"\?SimpleMethod@Methods@@QEAAHH@Z"}}(%class.Methods* [[THIS_PTR2]], i32{{( signext)?}} 4) @@ -39,7 +39,7 @@ func basicMethods(a: UnsafeMutablePointer) -> Int32 { return a.pointee.SimpleMethod(4) } -// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir17basicMethodsConst1as5Int32VSpySo0D0VG_tF"(i8*) +// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir17basicMethodsConst1as5Int32VSpySo0D0VG_tF"(i8* %0) // CHECK: [[THIS_PTR1:%.*]] = bitcast i8* %0 to %TSo7MethodsV* // CHECK: [[THIS_PTR2:%.*]] = bitcast %TSo7MethodsV* [[THIS_PTR1]] to %class.Methods* // CHECK: [[RESULT:%.*]] = call {{(signext )?}}i32 @{{_ZNK7Methods17SimpleConstMethodEi|"\?SimpleConstMethod@Methods@@QEBAHH@Z"}}(%class.Methods* [[THIS_PTR2]], i32{{( signext)?}} 3) @@ -55,7 +55,7 @@ func basicMethodsStatic() -> Int32 { return Methods.SimpleStaticMethod(5) } -// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir12basicMethods1as5Int32VSpySo8Methods2VG_tF"(i8*) +// CHECK-LABEL: define hidden swiftcc i32 @"$s6cxx_ir12basicMethods1as5Int32VSpySo8Methods2VG_tF"(i8* %0) // CHECK: [[THIS_PTR1:%.*]] = bitcast i8* %0 to %TSo8Methods2V* // CHECK: [[THIS_PTR2:%.*]] = bitcast %TSo8Methods2V* [[THIS_PTR1]] to %class.Methods2* // CHECK: [[RESULT:%.*]] = call {{(signext )?}}i32 @{{_ZN8Methods212SimpleMethodEi|"\?SimpleMethod@Methods2@@QEAAHH@Z"}}(%class.Methods2* [[THIS_PTR2]], i32{{( signext)?}} 4) diff --git a/test/ClangImporter/enum-cxx.swift b/test/ClangImporter/enum-cxx.swift index 73ecea81def5e..281e31e3dc6f1 100644 --- a/test/ClangImporter/enum-cxx.swift +++ b/test/ClangImporter/enum-cxx.swift @@ -2,7 +2,7 @@ import CXXInterop -// CHECK-LABEL: define hidden swiftcc i8 @"$s4main19testEmptyEnumImport5values4Int8VSo04OpencD0V_tF"(i8) +// CHECK-LABEL: define hidden swiftcc i8 @"$s4main19testEmptyEnumImport5values4Int8VSo04OpencD0V_tF"(i8 %0) // CHECK: %1 = call swiftcc i8 @"$sSo13OpenEmptyEnumV8rawValues4Int8Vvg"(i8 %0) // CHECK: ret i8 %1 func testEmptyEnumImport(value: OpenEmptyEnum) -> Int8 { diff --git a/test/ClangImporter/objc_ir.swift b/test/ClangImporter/objc_ir.swift index a1c86412e33c6..73eee22244930 100644 --- a/test/ClangImporter/objc_ir.swift +++ b/test/ClangImporter/objc_ir.swift @@ -98,7 +98,7 @@ func almostSubscriptable(as1 as1: AlmostSubscriptable, a: A) { as1.objectForKeyedSubscript(a) } -// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir13protocolTypes1a1bySo7NSMinceC_So9NSRuncing_ptF"(%TSo7NSMinceC*, %objc_object*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir13protocolTypes1a1bySo7NSMinceC_So9NSRuncing_ptF"(%TSo7NSMinceC* %0, %objc_object* %1) {{.*}} { func protocolTypes(a a: NSMince, b: NSRuncing) { // - (void)eatWith:(id )runcer; a.eat(with: b) @@ -106,7 +106,7 @@ func protocolTypes(a a: NSMince, b: NSRuncing) { // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OPAQUE:%.*]]*, i8*, i8*)*)([[OPAQUE:%.*]]* {{%.*}}, i8* [[SEL]], i8* {{%.*}}) } -// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir6getset1pySo8FooProto_p_tF"(%objc_object*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir6getset1pySo8FooProto_p_tF"(%objc_object* %0) {{.*}} { func getset(p p: FooProto) { // CHECK: load i8*, i8** @"\01L_selector(bar)" // CHECK: load i8*, i8** @"\01L_selector(setBar:)" @@ -114,7 +114,7 @@ func getset(p p: FooProto) { p.bar = prop } -// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir16protocolMetatype1pSo8FooProto_pXpSoAD_p_tF"(%objc_object*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir16protocolMetatype1pSo8FooProto_pXpSoAD_p_tF"(%objc_object* %0) {{.*}} { func protocolMetatype(p: FooProto) -> FooProto.Type { // CHECK: = call %swift.type* @swift_getObjectType(%objc_object* %0) // CHECK-NOT: {{retain|release}} @@ -131,7 +131,7 @@ class Impl: FooProto, AnotherProto { @objc var bar: Int32 = 0 } -// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir27protocolCompositionMetatype1pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir27protocolCompositionMetatype1pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC* %0) {{.*}} { func protocolCompositionMetatype(p: Impl) -> (FooProto & AnotherProto).Type { // CHECK: = getelementptr inbounds %T7objc_ir4ImplC, %T7objc_ir4ImplC* %0, i32 0, i32 0, i32 0 // CHECK-NOT: {{retain|release}} @@ -144,7 +144,7 @@ func protocolCompositionMetatype(p: Impl) -> (FooProto & AnotherProto).Type { return type } // CHECK: } -// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir28protocolCompositionMetatype21pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s7objc_ir28protocolCompositionMetatype21pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC* %0) {{.*}} { func protocolCompositionMetatype2(p: Impl) -> (FooProto & AnotherProto).Type { // CHECK: = getelementptr inbounds %T7objc_ir4ImplC, %T7objc_ir4ImplC* %0, i32 0, i32 0, i32 0 // CHECK-NOT: {{retain|release}} @@ -157,7 +157,7 @@ func protocolCompositionMetatype2(p: Impl) -> (FooProto & AnotherProto).Type { return type } // CHECK: } -// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir17pointerPropertiesyySo14PointerWrapperCF"(%TSo14PointerWrapperC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir17pointerPropertiesyySo14PointerWrapperCF"(%TSo14PointerWrapperC* %0) {{.*}} { func pointerProperties(_ obj: PointerWrapper) { // CHECK: load i8*, i8** @"\01L_selector(setVoidPtr:)" // CHECK: load i8*, i8** @"\01L_selector(setIntPtr:)" @@ -167,7 +167,7 @@ func pointerProperties(_ obj: PointerWrapper) { obj.idPtr = nil as AutoreleasingUnsafeMutablePointer? } -// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir16strangeSelectorsyySo13SwiftNameTestCF"(%TSo13SwiftNameTestC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s7objc_ir16strangeSelectorsyySo13SwiftNameTestCF"(%TSo13SwiftNameTestC* %0) {{.*}} { func strangeSelectors(_ obj: SwiftNameTest) { // CHECK: load i8*, i8** @"\01L_selector(:b:)" obj.empty(a: 0, b: 0) diff --git a/test/ClangImporter/static_inline.swift b/test/ClangImporter/static_inline.swift index f6e6e95d091f0..2fcba5995d58d 100644 --- a/test/ClangImporter/static_inline.swift +++ b/test/ClangImporter/static_inline.swift @@ -8,7 +8,7 @@ // CHECK: sil shared [serializable] [clang c_inline_func] @c_inline_func : $@convention(c) (Int32) -> Int32 -// CHECK-IR-LABEL: define{{.*}} i32 @"$s13static_inline6testit1xs5Int32VAE_tF"(i32) +// CHECK-IR-LABEL: define{{.*}} i32 @"$s13static_inline6testit1xs5Int32VAE_tF"(i32 %0) // CHECK-IR: = add {{.*}}, 27 // CHECK-IR: ret diff --git a/test/ClangImporter/static_inline_serialize.swift b/test/ClangImporter/static_inline_serialize.swift index e5a911da06243..6f2e259ce22b4 100644 --- a/test/ClangImporter/static_inline_serialize.swift +++ b/test/ClangImporter/static_inline_serialize.swift @@ -8,7 +8,7 @@ // CHECK: sil shared_external [clang c_inline_func] @c_inline_func : $@convention(c) (Int32) -> Int32 -// CHECK-IR-LABEL: define{{.*}} i32 @"$s4test6mytest1xs5Int32VAE_tF"(i32) +// CHECK-IR-LABEL: define{{.*}} i32 @"$s4test6mytest1xs5Int32VAE_tF"(i32 %0) // CHECK-IR: = add {{.*}}, 27 // CHECK-IR: ret diff --git a/test/ClangImporter/system-framework-search-path.swift b/test/ClangImporter/system-framework-search-path.swift index fb15e9153df4d..b4d7c6f750602 100644 --- a/test/ClangImporter/system-framework-search-path.swift +++ b/test/ClangImporter/system-framework-search-path.swift @@ -7,6 +7,6 @@ // RUN: %FileCheck -input-file=%t/stderr-as-user.txt %s -check-prefix=CHECK-USER // RUN: %FileCheck -input-file=%t/stderr-as-system.txt %s -check-prefix=CHECK-SYSTEM --allow-empty -// CHECK-USER: control reaches end of non-void function -// CHECK-SYSTEM-NOT: control reaches end of non-void function +// CHECK-USER: non-void function does not return a value +// CHECK-SYSTEM-NOT: non-void function does not return a value import Module diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift index 043775a16017c..b9ffb4a484c80 100644 --- a/test/Constraints/diagnostics.swift +++ b/test/Constraints/diagnostics.swift @@ -127,7 +127,9 @@ protocol Shoes { // Here the opaque value has type (metatype_type (archetype_type ... )) func f(_ x: Shoes, asType t: Shoes.Type) { - return t.select(x) // expected-error{{unexpected non-void return value in void function}} + return t.select(x) + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } precedencegroup Starry { @@ -184,7 +186,9 @@ func perform() {} // expected-error {{generic parameter 'T' is not used in f // Error Message QOI - wrong return type in an overload func recArea(_ h: Int, w : Int) { - return h * w // expected-error {{unexpected non-void return value in void function}} + return h * w + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } // QoI: Error In Ternary Condition is Wrong @@ -752,7 +756,9 @@ func segfault23433271(_ a : UnsafeMutableRawPointer) { // Poor diagnostic due to contextual constraint func r23272739(_ contentType: String) { let actualAcceptableContentTypes: Set = [] - return actualAcceptableContentTypes.contains(contentType) // expected-error {{unexpected non-void return value in void function}} + return actualAcceptableContentTypes.contains(contentType) + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } // QoI: Strings in Swift cannot be indexed directly with integer offsets @@ -863,8 +869,8 @@ class Foo23752537 { extension Foo23752537 { func isEquivalent(other: Foo23752537) { // TODO: QoI: Nonsensical "binary operator '&&' cannot be applied to two 'Bool' operands" - // expected-error @+1 {{unexpected non-void return value in void function}} - return (self.title != other.title && self.message != other.message) + // expected-error@+1 {{unexpected non-void return value in void function}} + return (self.title != other.title && self.message != other.message) // expected-note {{did you mean to add a return type?}} } } @@ -890,7 +896,9 @@ func f23213302() { // QoI: Return of call to overloaded function in void-return context func rdar24202058(a : Int) { - return a <= 480 // expected-error {{unexpected non-void return value in void function}} + return a <= 480 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } // SR-1752: Warning about unused result with ternary operator @@ -953,7 +961,9 @@ r27212391(a: 1, 3, x: 5) // expected-error {{argument 'x' must precede unname // SR-1255 func foo1255_1() { - return true || false // expected-error {{unexpected non-void return value in void function}} + return true || false + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } func foo1255_2() -> Int { return true || false // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}} @@ -1150,6 +1160,7 @@ func sr5045() { let doubles: [Double] = [1, 2, 3] return doubles.reduce(0, +) // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } // rdar://problem/32934129 - QoI: misleading diagnostic @@ -1165,7 +1176,9 @@ class L_32934129 { func length() -> Int { func inner(_ list: L_32934129?, _ count: Int) { - guard let list = list else { return count } // expected-error {{unexpected non-void return value in void function}} + guard let list = list else { return count } + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} return inner(list.next, count + 1) } @@ -1315,3 +1328,60 @@ takesGenericFunction(true) // expected-error {{cannot convert value of type 'Boo func takesTuple(_ x: ([T], [T])) {} // expected-note {{in call to function 'takesTuple'}} takesTuple(true) // expected-error {{cannot convert value of type 'Bool' to expected argument type '([T], [T])'}} // expected-error@-1 {{generic parameter 'T' could not be inferred}} + +// Void function returns non-void result fix-it + +func voidFunc() { + return 1 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}}{{16-16= -> <#Return Type#>}} +} + +func voidFuncWithArgs(arg1: Int) { + return 1 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}}{{33-33= -> <#Return Type#>}} +} + +func voidFuncWithCondFlow() { + if Bool.random() { + return 1 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}}{{28-28= -> <#Return Type#>}} + } else { + return 2 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}}{{28-28= -> <#Return Type#>}} + } +} + +func voidFuncWithNestedVoidFunc() { + func nestedVoidFunc() { + return 1 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}}{{24-24= -> <#Return Type#>}} + } +} + +// Special cases: These should not offer a note + fix-it + +func voidFuncExplicitType() -> Void { + return 1 // expected-error {{unexpected non-void return value in void function}} +} + +class ClassWithDeinit { + deinit { + return 0 // expected-error {{unexpected non-void return value in void function}} + } +} + +class ClassWithVoidProp { + var propertyWithVoidType: () { return 5 } // expected-error {{unexpected non-void return value in void function}} +} + +class ClassWithPropContainingSetter { + var propWithSetter: Int { + get { return 0 } + set { return 1 } // expected-error {{unexpected non-void return value in void function}} + } +} diff --git a/test/Constraints/overload.swift b/test/Constraints/overload.swift index 5838918cba3be..58d7ed89d9a06 100644 --- a/test/Constraints/overload.swift +++ b/test/Constraints/overload.swift @@ -135,7 +135,9 @@ func test_contextual_result_1() { } func test_contextual_result_2() { - return overloaded_identity(1) // expected-error {{unexpected non-void return value in void function}} + return overloaded_identity(1) + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } // rdar://problem/24128153 diff --git a/test/DebugInfo/ErrorVar.swift b/test/DebugInfo/ErrorVar.swift index b66f3d877cde5..ca921180dce4a 100644 --- a/test/DebugInfo/ErrorVar.swift +++ b/test/DebugInfo/ErrorVar.swift @@ -11,7 +11,10 @@ enum MyError : Error { // thrown error we create a shadow stack location holding the address of the // location that holds the pointer to the error instead. func simple(_ placeholder: Int64) throws -> () { - // CHECK: define {{.*}}void @"$s8ErrorVar6simpleyys5Int64VKF"(i64, %swift.refcounted* swiftself, %swift.error** noalias nocapture dereferenceable(4)) + // CHECK: define {{.*}}void @"$s8ErrorVar6simpleyys5Int64VKF"( + // CHECK-SAME: i64 + // CHECK-SAME: %swift.refcounted* {{.*}}swiftself + // CHECK-SAME: %swift.error** noalias nocapture dereferenceable(4) // CHECK: call void @llvm.dbg.declare // CHECK: call void @llvm.dbg.declare({{.*}}, metadata ![[ERROR:[0-9]+]], metadata !DIExpression(DW_OP_deref)) // CHECK: ![[ERRTY:.*]] = !DICompositeType({{.*}}identifier: "$ss5Error_pD" diff --git a/test/DebugInfo/Imports.swift b/test/DebugInfo/Imports.swift index 7163ab57451b5..5ba4bfe8eab22 100644 --- a/test/DebugInfo/Imports.swift +++ b/test/DebugInfo/Imports.swift @@ -7,7 +7,7 @@ // CHECK-DAG: ![[FOOMODULE:[0-9]+]] = !DIModule({{.*}}, name: "Foo", includePath: "{{.*}}test{{.*}}DebugInfo{{.*}}" // CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[THISFILE:[0-9]+]], entity: ![[FOOMODULE]] -// CHECK-DAG: ![[THISFILE]] = !DIFile(filename: "{{.*}}test{{/|\\5C}}DebugInfo{{/|\\5C}}Imports.swift", +// CHECK-DAG: ![[THISFILE]] = !DIFile(filename: "{{.*}}test{{/|\\\\}}DebugInfo{{/|\\\\}}Imports.swift", // CHECK-DAG: ![[SWIFTFILE:[0-9]+]] = !DIFile(filename: "{{.*}}Swift.swiftmodule{{(/.+[.]swiftmodule)?}}" // CHECK-DAG: ![[SWIFTMODULE:[0-9]+]] = !DIModule({{.*}}, name: "Swift" // CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[THISFILE]], entity: ![[SWIFTMODULE]] diff --git a/test/DebugInfo/ImportsStdlib.swift b/test/DebugInfo/ImportsStdlib.swift index 51598f652b603..c80499ab70583 100644 --- a/test/DebugInfo/ImportsStdlib.swift +++ b/test/DebugInfo/ImportsStdlib.swift @@ -11,7 +11,7 @@ // CHECK-DAG: ![[MODULE:[0-9]+]] = !DIModule({{.*}}, name: "NotTheStdlib", includePath: "{{.*}}test{{.*}}DebugInfo{{.*}}" // CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[THISFILE:[0-9]+]], entity: ![[MODULE]] -// CHECK-DAG: ![[THISFILE]] = !DIFile(filename: "{{.*}}test{{/|\\5C}}DebugInfo{{/|\\5C}}ImportsStdlib.swift" +// CHECK-DAG: ![[THISFILE]] = !DIFile(filename: "{{.*}}test{{/|\\\\}}DebugInfo{{/|\\\\}}ImportsStdlib.swift" // NEGATIVE-NOT: !DIFile(filename: "{{.*}}Swift.swiftmodule" // NEGATIVE-NOT: !DIModule({{.*}}, name: "Swift" diff --git a/test/DebugInfo/basic.swift b/test/DebugInfo/basic.swift index e8ab11b2f4236..9be8bc95e24d7 100644 --- a/test/DebugInfo/basic.swift +++ b/test/DebugInfo/basic.swift @@ -85,7 +85,7 @@ func foo(_ a: Int64, _ b: Int64) -> Int64 { // CHECK-DAG: ![[MAINMODULE]] = !DIModule({{.*}}, name: "basic" // DWARF Version -// DWARF-CHECK-DAG: i32 2, !"Dwarf Version", i32 4} +// DWARF-CHECK-DAG: i32 7, !"Dwarf Version", i32 4} // CV-CHECK-DAG: i32 2, !"CodeView", i32 1} // Debug Info Version diff --git a/test/DebugInfo/closure-arg-linetable.swift b/test/DebugInfo/closure-arg-linetable.swift index eb3ea153e3b13..7841c9606fff2 100644 --- a/test/DebugInfo/closure-arg-linetable.swift +++ b/test/DebugInfo/closure-arg-linetable.swift @@ -3,7 +3,7 @@ public class C { // Test that curry thunks don't have line table entries. - // CHECK: define {{.*}}@"$s4main1CC11someHandleryyFTc"(%T4main1CC*) + // CHECK: define {{.*}}@"$s4main1CC11someHandleryyFTc"(%T4main1CC* %0) // CHECK-SAME: !dbg ![[CURRY_THUNK:[0-9]+]] // CHECK-NOT: ret {{.*}}, // CHECK: {{.*}}, !dbg ![[DBG:[0-9]+]] diff --git a/test/DebugInfo/debug_prefix_map.swift b/test/DebugInfo/debug_prefix_map.swift index b894688a688ab..b6db3ce52a2de 100644 --- a/test/DebugInfo/debug_prefix_map.swift +++ b/test/DebugInfo/debug_prefix_map.swift @@ -9,4 +9,4 @@ func square(_ n: Int) -> Int { } // CHECK: !DIFile(filename: "/var/empty/debug_prefix_map.swift" -// CHECK: !DIModule(scope: null, name: "Globals", {{.*}}includePath: "/var/empty{{(/|\\5C)}}Globals.swiftmodule" +// CHECK: !DIModule(scope: null, name: "Globals", {{.*}}includePath: "/var/empty{{(/|\\\\)}}Globals.swiftmodule" diff --git a/test/DebugInfo/linetable-codeview.swift b/test/DebugInfo/linetable-codeview.swift index 77c7141e7a1ad..37b878030d159 100644 --- a/test/DebugInfo/linetable-codeview.swift +++ b/test/DebugInfo/linetable-codeview.swift @@ -32,7 +32,7 @@ func foo() { } // func arithmetic(_ a: Int64, _ b: Int64) - // CHECK: define {{.*}} @"$s4main10arithmeticyys5Int64V_ADtF"(i64, i64) + // CHECK: define {{.*}} @"$s4main10arithmeticyys5Int64V_ADtF"(i64 %0, i64 %1) // CHECK: call { i64, i1 } @llvm.sadd.with.overflow.i64({{.*}}), !dbg ![[ADD:[0-9]+]] // NOTE: The division will emit an ``unreachable`` instruction sandwiched // between other instructions for the division. We want to make sure diff --git a/test/DebugInfo/macro.swift b/test/DebugInfo/macro.swift index c9c75552fac35..82a5c376e54ae 100644 --- a/test/DebugInfo/macro.swift +++ b/test/DebugInfo/macro.swift @@ -6,7 +6,7 @@ // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "macro_enum", // CHECK-SAME: file: ![[MACRO_H:[0-9]+]] -// CHECK: ![[MACRO_H]] = !DIFile(filename: "{{.*}}{{(/|\\5C)}}Inputs{{(/|\\5C)}}Macro.h", +// CHECK: ![[MACRO_H]] = !DIFile(filename: "{{.*}}{{(/|\\\\)}}Inputs{{(/|\\\\)}}Macro.h", import Macro diff --git a/test/DebugInfo/struct_resilience.swift b/test/DebugInfo/struct_resilience.swift index 8855edb0e8f5b..c0cef08662558 100644 --- a/test/DebugInfo/struct_resilience.swift +++ b/test/DebugInfo/struct_resilience.swift @@ -11,8 +11,8 @@ // import resilient_struct -// CHECK-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience9takesSizeyy010resilient_A00D0VF"(%swift.opaque* noalias nocapture) -// CHECK-LLDB-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience9takesSizeyy010resilient_A00D0VF"(%T16resilient_struct4SizeV* noalias nocapture dereferenceable({{8|16}})) +// CHECK-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience9takesSizeyy010resilient_A00D0VF"(%swift.opaque* noalias nocapture %0) +// CHECK-LLDB-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience9takesSizeyy010resilient_A00D0VF"(%T16resilient_struct4SizeV* noalias nocapture dereferenceable({{8|16}}) %0) public func takesSize(_ s: Size) {} diff --git a/test/IDE/complete_cache.swift b/test/IDE/complete_cache.swift index 0cf4c25c2bef7..9370f41e99a6f 100644 --- a/test/IDE/complete_cache.swift +++ b/test/IDE/complete_cache.swift @@ -63,7 +63,7 @@ import ctypes // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]/recommendedover[Foo3, Foo2]: FooStruct4[#FooStruct4#]{{; name=.+$}} // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]: FooStruct5[#FooStruct5#]{{; name=.+$}} // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]/recommendedover[ro1, ro2, ro3, ro4]/recommended[r1, r2, r3]/keyword[k1, k2, k3, k4]: FooStruct6[#FooStruct6#]{{; name=.+$}} -// CLANG_CTYPES-DAG: Decl[TypeAlias]/OtherModule[ctypes]: FooStructTypedef1[#FooStruct2#]{{; name=.+$}} +// CLANG_CTYPES-DAG: Decl[TypeAlias]/OtherModule[ctypes]/keyword[Foo2]: FooStructTypedef1[#FooStruct2#]{{; name=.+$}} // CLANG_CTYPES: End completions // CLANG_MACROS: Begin completions diff --git a/test/IDE/complete_from_clang_importer_framework.swift b/test/IDE/complete_from_clang_importer_framework.swift index 1a4fe14b2984a..93da9f2b5d1b7 100644 --- a/test/IDE/complete_from_clang_importer_framework.swift +++ b/test/IDE/complete_from_clang_importer_framework.swift @@ -18,7 +18,7 @@ import Darwin // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]/recommendedover[Foo3, Foo2]: FooStruct4[#FooStruct4#]{{; name=.+$}} // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]: FooStruct5[#FooStruct5#]{{; name=.+$}} // CLANG_CTYPES-DAG: Decl[Struct]/OtherModule[ctypes]/recommendedover[ro1, ro2, ro3, ro4]/recommended[r1, r2, r3]/keyword[k1, k2, k3, k4]: FooStruct6[#FooStruct6#]{{; name=.+$}} -// CLANG_CTYPES-DAG: Decl[TypeAlias]/OtherModule[ctypes]: FooStructTypedef1[#FooStruct2#]{{; name=.+$}} +// CLANG_CTYPES-DAG: Decl[TypeAlias]/OtherModule[ctypes]/keyword[Foo2]: FooStructTypedef1[#FooStruct2#]{{; name=.+$}} // CLANG_CTYPES: End completions // CLANG_MACROS: Begin completions diff --git a/test/IDE/print_clang_decls.swift b/test/IDE/print_clang_decls.swift index 312fe0907985d..ee6e5aef34fc3 100644 --- a/test/IDE/print_clang_decls.swift +++ b/test/IDE/print_clang_decls.swift @@ -42,6 +42,9 @@ // TAG_DECLS_AND_TYPEDEFS-NEXT: {{^}} init(x: Int32, y: Double){{$}} // TAG_DECLS_AND_TYPEDEFS-NEXT: {{^}}}{{$}} +// TAG_DECLS_AND_TYPEDEFS: /** +// TAG_DECLS_AND_TYPEDEFS-NEXT: @keyword Foo2 +// TAG_DECLS_AND_TYPEDEFS-NEXT: */ // TAG_DECLS_AND_TYPEDEFS-NEXT: {{^}}typealias FooStructTypedef1 = FooStruct2{{$}} // TAG_DECLS_AND_TYPEDEFS-NEXT: {{^}}struct FooStructTypedef2 {{{$}} diff --git a/test/IRGen/TestABIInaccessible.swift b/test/IRGen/TestABIInaccessible.swift index 06c59405f6507..0078db19077dd 100644 --- a/test/IRGen/TestABIInaccessible.swift +++ b/test/IRGen/TestABIInaccessible.swift @@ -8,7 +8,7 @@ public struct AnotherType { } // Don't pass the metadata of Private to AnotherType's outlined destroy. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s4main4copyyAA11AnotherTypeVyxGAElF"(%T4main11AnotherTypeV* noalias nocapture sret, %T4main11AnotherTypeV* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s4main4copyyAA11AnotherTypeVyxGAElF"(%T4main11AnotherTypeV* noalias nocapture sret %0, %T4main11AnotherTypeV* noalias nocapture %1, %swift.type* %T) // CHECK: [[MD:%.*]] = call swiftcc %swift.metadata_response @"$s4main11AnotherTypeVMa"(i{{.*}} 0, %swift.type* %T) // CHECK: [[MD1:%.*]] = extractvalue %swift.metadata_response [[MD]], 0 // CHECK: [[MD2:%.*]] = call swiftcc %swift.metadata_response @"$s4main6PublicVMa"(i{{.*}} 0, %swift.type* %T) diff --git a/test/IRGen/abitypes.swift b/test/IRGen/abitypes.swift index 9c27c7d4674cd..987268529d2e9 100644 --- a/test/IRGen/abitypes.swift +++ b/test/IRGen/abitypes.swift @@ -18,58 +18,58 @@ import Foundation // armv7k-watchos: [[ARMV7K_MYRECT:%.*]] = type { float, float, float, float } class Foo { - // x86_64-macosx: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { - // x86_64-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-ios: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { - // i386-ios: define hidden swiftcc void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%TSo6MyRectV* noalias nocapture sret, %T8abitypes3FooC* swiftself) {{.*}} { - // i386-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret, i8*, i8*) {{[#0-9]*}} { - // armv7-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // armv7-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret, i8*, i8*) {{[#0-9]*}} { - // armv7s-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // armv7s-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret, i8*, i8*) {{[#0-9]*}} { - // arm64-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // arm64-ios: define hidden [[ARM64_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { - // x86_64-tvos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-tvos: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { - // arm64-tvos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // arm64-tvos: define hidden [[ARM64_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { - // i386-watchos: define hidden swiftcc void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%TSo6MyRectV* noalias nocapture sret, %T8abitypes3FooC* swiftself) {{.*}} { - // i386-watchos: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret, i8*, i8*) {{[#0-9]*}} { - // armv7k-watchos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // armv7k-watchos: define hidden [[ARMV7K_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // x86_64-macosx: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { + // x86_64-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // x86_64-ios: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { + // i386-ios: define hidden swiftcc void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%TSo6MyRectV* noalias nocapture sret %0, %T8abitypes3FooC* swiftself %1) {{.*}} { + // i386-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret %0, i8* %1, i8* %2) {{[#0-9]*}} { + // armv7-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // armv7-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret %0, i8* %1, i8* %2) {{[#0-9]*}} { + // armv7s-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // armv7s-ios: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret %0, i8* %1, i8* %2) {{[#0-9]*}} { + // arm64-ios: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // arm64-ios: define hidden [[ARM64_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { + // x86_64-tvos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // x86_64-tvos: define hidden { <2 x float>, <2 x float> } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { + // arm64-tvos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // arm64-tvos: define hidden [[ARM64_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { + // i386-watchos: define hidden swiftcc void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%TSo6MyRectV* noalias nocapture sret %0, %T8abitypes3FooC* swiftself %1) {{.*}} { + // i386-watchos: define hidden void @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(%TSo6MyRectV* noalias nocapture sret %0, i8* %1, i8* %2) {{[#0-9]*}} { + // armv7k-watchos: define hidden swiftcc { float, float, float, float } @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // armv7k-watchos: define hidden [[ARMV7K_MYRECT]] @"$s8abitypes3FooC3bar{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { @objc dynamic func bar() -> MyRect { return MyRect(x: 1, y: 2, width: 3, height: 4) } - // x86_64-macosx: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(double, double, double, double, %T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, %TSo6CGRectV* byval align 8) {{[#0-9]*}} { - // armv7-ios: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7-ios: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x i32]) {{[#0-9]*}} { - // armv7s-ios: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7s-ios: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x i32]) {{[#0-9]*}} { - // armv7k-watchos: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7k-watchos: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x float]) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(double %0, double %1, double %2, double %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // x86_64-macosx: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, %TSo6CGRectV* byval align 8 %2) {{[#0-9]*}} { + // armv7-ios: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // armv7-ios: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x i32] %2) {{[#0-9]*}} { + // armv7s-ios: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %3) {{.*}} { + // armv7s-ios: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x i32] %3) {{[#0-9]*}} { + // armv7k-watchos: define hidden swiftcc double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // armv7k-watchos: define hidden double @"$s8abitypes3FooC14getXFromNSRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x float] %2) {{[#0-9]*}} { @objc dynamic func getXFromNSRect(_ r: NSRect) -> Double { return Double(r.origin.x) } - // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, <2 x float>, <2 x float>) {{[#0-9]*}} { - // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7-ios: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x i32]) {{[#0-9]*}} { - // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7s-ios: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x i32]) {{[#0-9]*}} { - // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { - // armv7k-watchos: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, [4 x float]) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // x86_64-macosx: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, <2 x float> %2, <2 x float> %3) {{[#0-9]*}} { + // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // armv7-ios: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x i32] %2) {{[#0-9]*}} { + // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // armv7s-ios: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x i32] %2) {{[#0-9]*}} { + // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { + // armv7k-watchos: define hidden float @"$s8abitypes3FooC12getXFromRect{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, [4 x float] %3) {{[#0-9]*}} { @objc dynamic func getXFromRect(_ r: MyRect) -> Float { return r.x } // Call from Swift entrypoint with exploded Rect to @objc entrypoint // with unexploded ABI-coerced type. - // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{.*}}"(float, float, float, float, [[SELF:%.*]]* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{.*}}"(float %0, float %1, float %2, float %3, [[SELF:%.*]]* swiftself %4) {{.*}} { // x86_64-macosx: [[COERCED:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 8 // x86_64-macosx: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(getXFromRect:)", align 8 // x86_64-macosx: [[CAST:%.*]] = bitcast [[MYRECT]]* [[COERCED]] to { <2 x float>, <2 x float> }* @@ -79,7 +79,7 @@ class Foo { // x86_64-macosx: [[SECOND_HALF:%.*]] = load <2 x float>, <2 x float>* [[T0]] // x86_64-macosx: [[SELFCAST:%.*]] = bitcast [[SELF]]* %4 to i8* // x86_64-macosx: [[RESULT:%.*]] = call float bitcast (void ()* @objc_msgSend to float (i8*, i8*, <2 x float>, <2 x float>)*)(i8* [[SELFCAST]], i8* [[SEL]], <2 x float> [[FIRST_HALF]], <2 x float> [[SECOND_HALF]]) - // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float, float, float, float, [[SELF:%.*]]* swiftself) {{.*}} { + // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, [[SELF:%.*]]* swiftself %4) {{.*}} { // armv7-ios: [[DEBUGVAR:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7-ios: [[COERCED:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7-ios: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(getXFromRect:)", align 4 @@ -88,7 +88,7 @@ class Foo { // armv7-ios: [[SELFCAST:%.*]] = bitcast [[SELF]]* %4 to i8* // armv7-ios: [[RESULT:%.*]] = call float bitcast (void ()* @objc_msgSend to float (i8*, i8*, [4 x i32])*)(i8* [[SELFCAST]], i8* [[SEL]], [4 x i32] [[LOADED]]) - // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float, float, float, float, [[SELF:%.*]]* swiftself) {{.*}} { + // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, [[SELF:%.*]]* swiftself %4) {{.*}} { // armv7s-ios: [[DEBUGVAR:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7s-ios: [[COERCED:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7s-ios: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(getXFromRect:)", align 4 @@ -97,7 +97,7 @@ class Foo { // armv7s-ios: [[SELFCAST:%.*]] = bitcast [[SELF]]* %4 to i8* // armv7s-ios: [[RESULT:%.*]] = call float bitcast (void ()* @objc_msgSend to float (i8*, i8*, [4 x i32])*)(i8* [[SELFCAST]], i8* [[SEL]], [4 x i32] [[LOADED]]) - // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float, float, float, float, [[SELF:%.*]]* swiftself) {{.*}} { + // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC17getXFromRectSwift{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, [[SELF:%.*]]* swiftself %4) {{.*}} { // armv7k-watchos: [[DEBUGVAR:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7k-watchos: [[COERCED:%.*]] = alloca [[MYRECT:%.*MyRect.*]], align 4 // armv7k-watchos: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(getXFromRect:)", align 4 @@ -110,7 +110,7 @@ class Foo { } // Ensure that MyRect is passed as an indirect-byval on x86_64 because we run out of registers for direct arguments - // x86_64-macosx: define hidden float @"$s8abitypes3FooC25getXFromRectIndirectByVal{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, float, float, float, float, float, float, float, %TSo6MyRectV* byval align 8) {{[#0-9]*}} { + // x86_64-macosx: define hidden float @"$s8abitypes3FooC25getXFromRectIndirectByVal{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, %TSo6MyRectV* byval align 8 %9) {{[#0-9]*}} { @objc dynamic func getXFromRectIndirectByVal(_: Float, second _: Float, third _: Float, fourth _: Float, fifth _: Float, sixth _: Float, @@ -120,7 +120,7 @@ class Foo { } // Make sure the caller-side from Swift also uses indirect-byval for the argument - // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC25getXFromRectIndirectSwift{{[_0-9a-zA-Z]*}}F"(float, float, float, float, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC25getXFromRectIndirectSwift{{[_0-9a-zA-Z]*}}F"(float %0, float %1, float %2, float %3, %T8abitypes3FooC* swiftself %4) {{.*}} { func getXFromRectIndirectSwift(_ r: MyRect) -> Float { let f : Float = 1.0 // x86_64-macosx: alloca @@ -132,7 +132,7 @@ class Foo { } // x86_64 returns an HA of four floats directly in two <2 x float> - // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: load i8*, i8** @"\01L_selector(newRect)", align 8 // x86_64-macosx: [[RESULT:%.*]] = call { <2 x float>, <2 x float> } bitcast (void ()* @objc_msgSend // x86_64-macosx: store { <2 x float>, <2 x float> } [[RESULT]] @@ -141,7 +141,7 @@ class Foo { // x86_64-macosx: ret float // // armv7 returns an HA of four floats indirectly - // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7-ios: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // armv7-ios: [[RESULT:%.*]] = alloca [[RECTTYPE:%.*MyRect.*]], align 4 // armv7-ios: load i8*, i8** @"\01L_selector(newRect)", align 4 // armv7-ios: call void bitcast (void ()* @objc_msgSend_stret to void ([[RECTTYPE]]*, [[RECEIVER:.*]]*, i8*)*)([[RECTTYPE]]* noalias nocapture sret %call.aggresult @@ -151,7 +151,7 @@ class Foo { // armv7-ios: ret float [[RETVAL]] // // armv7s returns an HA of four floats indirectly - // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7s-ios: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself % %1) {{.*}} { // armv7s-ios: [[RESULT:%.*]] = alloca [[RECTTYPE:%.*MyRect.*]], align 4 // armv7s-ios: load i8*, i8** @"\01L_selector(newRect)", align 4 // armv7s-ios: call void bitcast (void ()* @objc_msgSend_stret to void ([[RECTTYPE]]*, [[RECEIVER:.*]]*, i8*)*)([[RECTTYPE]]* noalias nocapture sret %call.aggresult @@ -161,7 +161,7 @@ class Foo { // armv7s-ios: ret float [[RETVAL]] // // armv7k returns an HA of four floats directly - // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7k-watchos: define hidden swiftcc float @"$s8abitypes3FooC4barc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // armv7k-watchos: load i8*, i8** @"\01L_selector(newRect)", align 4 // armv7k-watchos: [[RESULT:%.*]] = call [[ARMV7K_MYRECT]] bitcast (void ()* @objc_msgSend // armv7k-watchos: store [[ARMV7K_MYRECT]] [[RESULT]] @@ -172,13 +172,13 @@ class Foo { return p.newRect().y } - // x86_64-macosx: define hidden swiftcc { double, double, double } @"$s8abitypes3FooC3baz{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden void @"$s8abitypes3FooC3baz{{[_0-9a-zA-Z]*}}FTo"(%TSo4TrioV* noalias nocapture sret, i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc { double, double, double } @"$s8abitypes3FooC3baz{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // x86_64-macosx: define hidden void @"$s8abitypes3FooC3baz{{[_0-9a-zA-Z]*}}FTo"(%TSo4TrioV* noalias nocapture sret %0, i8* %1, i8* %2) {{[#0-9]*}} { @objc dynamic func baz() -> Trio { return Trio(i: 1.0, j: 2.0, k: 3.0) } - // x86_64-macosx: define hidden swiftcc double @"$s8abitypes3FooC4bazc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc double @"$s8abitypes3FooC4bazc{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: load i8*, i8** @"\01L_selector(newTrio)", align 8 // x86_64-macosx: [[CAST:%[0-9]+]] = bitcast {{%.*}}* %0 // x86_64-macosx: call void bitcast (void ()* @objc_msgSend_stret to void (%TSo4TrioV*, [[OPAQUE:.*]]*, i8*)*) @@ -186,7 +186,7 @@ class Foo { return p.newTrio().j } - // x86_64-macosx: define hidden swiftcc i64 @"$s8abitypes3FooC7getpair{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc i64 @"$s8abitypes3FooC7getpair{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: [[RESULT:%.*]] = call i64 bitcast (void ()* @objc_msgSend to i64 ([[OPAQUE:.*]]*, i8*)*) // x86_64-macosx: [[GEP1:%.*]] = getelementptr inbounds { i64 }, { i64 }* {{.*}}, i32 0, i32 0 // x86_64-macosx: store i64 [[RESULT]], i64* [[GEP1]] @@ -197,12 +197,12 @@ class Foo { return p.newPair() } - // x86_64-macosx: define hidden i64 @"$s8abitypes3FooC8takepair{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i64) {{[#0-9]*}} { + // x86_64-macosx: define hidden i64 @"$s8abitypes3FooC8takepair{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i64 %2) {{[#0-9]*}} { @objc dynamic func takepair(_ p: IntPair) -> IntPair { return p } - // x86_64-macosx: define hidden swiftcc i64 @"$s8abitypes3FooC9getnested{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc i64 @"$s8abitypes3FooC9getnested{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: call i64 bitcast (void ()* @objc_msgSend to i64 ([[OPAQUE:.*]]*, i8*)*) // x86_64-macosx: bitcast // x86_64-macosx: call void @llvm.lifetime.start @@ -217,7 +217,7 @@ class Foo { return p.newNestedInts() } - // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC9copyClass{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC9copyClass{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8* %2) {{[#0-9]*}} { // x86_64-macosx: [[VALUE:%[0-9]+]] = call swiftcc [[TYPE:%.*]]* @"$s8abitypes3FooC9copyClass{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[T0:%.*]] = call [[OBJC:%objc_class]]* @swift_getObjCClassFromMetadata([[TYPE]]* [[VALUE]]) // x86_64-macosx: [[RESULT:%[0-9]+]] = bitcast [[OBJC]]* [[T0]] to i8* @@ -226,7 +226,7 @@ class Foo { return a } - // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC9copyProto{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC9copyProto{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8* %2) {{[#0-9]*}} { // x86_64-macosx: [[VALUE:%[0-9]+]] = call swiftcc [[TYPE:%.*]] @"$s8abitypes3FooC9copyProto{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[RESULT:%[0-9]+]] = bitcast [[TYPE]] [[VALUE]] to i8* // x86_64-macosx: ret i8* [[RESULT]] @@ -234,7 +234,7 @@ class Foo { return a } - // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC13copyProtoComp{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden i8* @"$s8abitypes3FooC13copyProtoComp{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8* %2) {{[#0-9]*}} { // x86_64-macosx: [[VALUE:%[0-9]+]] = call swiftcc [[TYPE:%.*]] @"$s8abitypes3FooC13copyProtoComp{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[RESULT:%[0-9]+]] = bitcast [[TYPE]] [[VALUE]] to i8* // x86_64-macosx: ret i8* [[RESULT]] @@ -242,22 +242,22 @@ class Foo { return a } - // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden signext i8 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { + // x86_64-macosx: define hidden signext i8 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) {{[#0-9]*}} { // x86_64-macosx: [[R1:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[R2:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[R3:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[R2]] // x86_64-macosx: ret i8 [[R3]] // - // x86_64-ios-fixme: define hidden i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC*) {{.*}} { + // x86_64-ios-fixme: define hidden i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* %1) {{.*}} { // x86_64-ios-fixme: define internal zeroext i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo" // x86_64-ios-fixme: [[R1:%[0-9]+]] = call i1 @"$s10ObjectiveC22_convertObjCBoolToBoolSbAA0cD0V1x_tF"(i1 %2) // x86_64-ios-fixme: [[R2:%[0-9]+]] = call i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 [[R1]] // x86_64-ios-fixme: [[R3:%[0-9]+]] = call i1 @"$s10ObjectiveC22_convertBoolToObjCBoolAA0eF0VSb1x_tF"(i1 [[R2]]) // x86_64-ios-fixme: ret i1 [[R3]] // - // armv7-ios-fixme: define hidden i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC*) {{.*}} { - // armv7-ios-fixme: define internal signext i8 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) {{[#0-9]*}} { + // armv7-ios-fixme: define hidden i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* %1) {{.*}} { + // armv7-ios-fixme: define internal signext i8 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) {{[#0-9]*}} { // armv7-ios-fixme: [[R1:%[0-9]+]] = call i1 @"$s10ObjectiveC22_convertObjCBoolToBool1xSbAA0cD0V_tF" // armv7-ios-fixme: [[R2:%[0-9]+]] = call i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 [[R1]] // armv7-ios-fixme: [[R3:%[0-9]+]] = call i8 @"$s10ObjectiveC22_convertBoolToObjCBoolAA0eF0VSb1x_tF"(i1 [[R2]] @@ -294,7 +294,7 @@ class Foo { // arm64-tvos-fixme: [[R2:%[0-9]+]] = call i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F" // arm64-tvos-fixme: ret i1 [[R2]] - // i386-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) + // i386-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) // i386-watchos: define hidden zeroext i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}FTo" // i386-watchos: [[R1:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBoolySbAA0cD0VF"(i1 %2) // i386-watchos: [[R2:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC6negate{{[_0-9a-zA-Z]*}}F"(i1 [[R1]] @@ -305,114 +305,114 @@ class Foo { return !b } - // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 %0) // x86_64-macosx: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 8 // x86_64-macosx: [[NEG:%[0-9]+]] = call signext i8 bitcast (void ()* @objc_msgSend to i8 ([[RECEIVER:.*]]*, i8*, i8)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i8 signext [[TOOBJCBOOL]]) // x86_64-macosx: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F"(i8 [[NEG]]) // x86_64-macosx: ret i1 [[TOBOOL]] // - // x86_64-macosx: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) + // x86_64-macosx: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) // x86_64-macosx: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F" // x86_64-macosx: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 [[TOBOOL]] // x86_64-macosx: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // x86_64-macosx: ret i8 [[TOOBJCBOOL]] // - // x86_64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 8 // x86_64-ios: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // x86_64-ios: ret i1 [[NEG]] // - // x86_64-ios: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // x86_64-ios: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // x86_64-ios: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // x86_64-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // x86_64-ios: ret i1 [[TOOBJCBOOL]] // - // armv7-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // armv7-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 %0) // armv7-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 4 // armv7-ios: [[NEG:%[0-9]+]] = call signext i8 bitcast (void ()* @objc_msgSend to i8 ([[RECEIVER:.*]]*, i8*, i8)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i8 signext [[TOOBJCBOOL]]) // armv7-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F"(i8 [[NEG]]) // armv7-ios: ret i1 [[TOBOOL]] // - // armv7-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) + // armv7-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) // armv7-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F" // armv7-ios: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 [[TOBOOL]] // armv7-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // armv7-ios: ret i8 [[TOOBJCBOOL]] // - // armv7s-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7s-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // armv7s-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 %0) // armv7s-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 4 // armv7s-ios: [[NEG:%[0-9]+]] = call signext i8 bitcast (void ()* @objc_msgSend to i8 ([[RECEIVER:.*]]*, i8*, i8)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i8 signext [[TOOBJCBOOL]]) // armv7s-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F"(i8 [[NEG]]) // armv7s-ios: ret i1 [[TOBOOL]] // - // armv7s-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) + // armv7s-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) // armv7s-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F" // armv7s-ios: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 [[TOBOOL]] // armv7s-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // armv7s-ios: ret i8 [[TOOBJCBOOL]] // - // arm64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // arm64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // arm64-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 8 // arm64-ios: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // arm64-ios: ret i1 [[NEG]] // - // arm64-ios: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // arm64-ios: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // arm64-ios: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // arm64-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // arm64-ios: ret i1 [[TOOBJCBOOL]] // - // i386-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // i386-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // i386-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 %0) // i386-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 4 // i386-ios: [[NEG:%[0-9]+]] = call signext i8 bitcast (void ()* @objc_msgSend to i8 ([[RECEIVER:.*]]*, i8*, i8)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i8 signext [[TOOBJCBOOL]]) // i386-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F"(i8 [[NEG]]) // i386-ios: ret i1 [[TOBOOL]] // - // i386-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8 signext) + // i386-ios: define hidden signext i8 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8 signext %2) // i386-ios: [[TOBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertObjCBoolToBool{{[_0-9a-zA-Z]*}}F" // i386-ios: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 [[TOBOOL]] // i386-ios: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i8 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // i386-ios: ret i8 [[TOOBJCBOOL]] // - // x86_64-tvos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-tvos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-tvos: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 8 // x86_64-tvos: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // x86_64-tvos: ret i1 [[NEG]] // - // x86_64-tvos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // x86_64-tvos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // x86_64-tvos: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // x86_64-tvos: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // x86_64-tvos: ret i1 [[TOOBJCBOOL]] // - // arm64-tvos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // arm64-tvos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // arm64-tvos: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 8 // arm64-tvos: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // arm64-tvos: ret i1 [[NEG]] // - // arm64-tvos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // arm64-tvos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // arm64-tvos: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // arm64-tvos: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // arm64-tvos: ret i1 [[TOOBJCBOOL]] - // i386-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // i386-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // i386-watchos: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 4 // i386-watchos: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // i386-watchos: ret i1 [[NEG]] // - // i386-watchos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // i386-watchos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // i386-watchos: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // i386-watchos: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // i386-watchos: ret i1 [[TOOBJCBOOL]] // - // armv7k-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // armv7k-watchos: define hidden swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // armv7k-watchos: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negate:)", align 4 // armv7k-watchos: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 ([[RECEIVER:.*]]*, i8*, i1)*)([[RECEIVER]]* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext %0) // armv7k-watchos: ret i1 [[NEG]] // - // armv7k-watchos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i1 zeroext) + // armv7k-watchos: define hidden zeroext i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i1 zeroext %2) // armv7k-watchos: [[NEG:%[0-9]+]] = call swiftcc i1 @"$s8abitypes3FooC7negate2{{[_0-9a-zA-Z]*}}F"(i1 // armv7k-watchos: [[TOOBJCBOOL:%[0-9]+]] = call swiftcc i1 @"$s10ObjectiveC22_convertBoolToObjCBool{{[_0-9a-zA-Z]*}}F"(i1 [[NEG]]) // armv7k-watchos: ret i1 [[TOOBJCBOOL]] @@ -422,19 +422,19 @@ class Foo { return g.negate(b) } - // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-macosx: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(invert:)", align 8 // x86_64-macosx: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 (%1*, i8*, i1)*)(%1* [[RECEIVER:%[0-9]+]], i8* [[SEL]], i1 zeroext %0) // x86_64-macosx: ret i1 [[NEG]] // x86_64-macosx: } - // x86_64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // x86_64-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(invert:)", align 8 // x86_64-ios: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 (%1*, i8*, i1)*)(%1* [[RECEIVER:%[0-9]+]], i8* [[SEL]], i1 zeroext %0) // x86_64-ios: ret i1 [[NEG]] // x86_64-ios: } - // i386-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1, %T8abitypes3FooC* swiftself) {{.*}} { + // i386-ios: define hidden swiftcc i1 @"$s8abitypes3FooC7negate3yS2bF"(i1 %0, %T8abitypes3FooC* swiftself %1) {{.*}} { // i386-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(invert:)", align 4 // i386-ios: [[NEG:%[0-9]+]] = call zeroext i1 bitcast (void ()* @objc_msgSend to i1 (%1*, i8*, i1)*)(%1* [[RECEIVER:%[0-9]+]], i8* [[SEL]], i1 zeroext %0) // i386-ios: ret i1 [[NEG]] @@ -445,17 +445,17 @@ class Foo { return g.invert(b) } - // x86_64-macosx: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1, %T8abitypes3FooC* swiftself, %swift.error** noalias nocapture swifterror dereferenceable(8)) {{.*}} { + // x86_64-macosx: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1 %0, %T8abitypes3FooC* swiftself %1, %swift.error** noalias nocapture swifterror dereferenceable(8) %2) {{.*}} { // x86_64-macosx: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negateThrowing:error:)", align 8 // x86_64-macosx: call signext i8 bitcast (void ()* @objc_msgSend to i8 (%1*, i8*, i8, %2**)*)(%1* {{%[0-9]+}}, i8* [[SEL]], i8 signext {{%[0-9]+}}, %2** {{%[0-9]+}}) // x86_64-macosx: } - // x86_64-ios: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1, %T8abitypes3FooC* swiftself, %swift.error** noalias nocapture swifterror dereferenceable(8)) {{.*}} { + // x86_64-ios: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1 %0, %T8abitypes3FooC* swiftself %1, %swift.error** noalias nocapture swifterror dereferenceable(8) %2) {{.*}} { // x86_64-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negateThrowing:error:)", align 8 // x86_64-ios: call zeroext i1 bitcast (void ()* @objc_msgSend to i1 (%1*, i8*, i1, %2**)*)(%1* {{%[0-9]+}}, i8* [[SEL]], i1 zeroext {{%[0-9]+}}, %2** {{%[0-9]+}}) // x86_64-ios: } - // i386-ios: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1, %T8abitypes3FooC* swiftself, %swift.error** noalias nocapture dereferenceable(4)) {{.*}} { + // i386-ios: define hidden swiftcc void @"$s8abitypes3FooC10throwsTestyySbKF"(i1 %0, %T8abitypes3FooC* swiftself %1, %swift.error** noalias nocapture dereferenceable(4) %2) {{.*}} { // i386-ios: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(negateThrowing:error:)", align 4 // i386-ios: call signext i8 bitcast (void ()* @objc_msgSend to i8 (%1*, i8*, i8, %2**)*)(%1* {{%[0-9]+}}, i8* [[SEL]], i8 signext {{%[0-9]+}}, %2** {{%[0-9]+}}) // i386-ios: } @@ -464,17 +464,17 @@ class Foo { try g.negateThrowing(b) } - // x86_64-macosx: define hidden i32* @"$s8abitypes3FooC24copyUnsafeMutablePointer{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i32*) {{[#0-9]*}} { + // x86_64-macosx: define hidden i32* @"$s8abitypes3FooC24copyUnsafeMutablePointer{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i32* %2) {{[#0-9]*}} { @objc dynamic func copyUnsafeMutablePointer(_ p: UnsafeMutablePointer) -> UnsafeMutablePointer { return p } - // x86_64-macosx: define hidden i64 @"$s8abitypes3FooC17returnNSEnumValue{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden i64 @"$s8abitypes3FooC17returnNSEnumValue{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { @objc dynamic func returnNSEnumValue() -> ByteCountFormatter.CountStyle { return .file } - // x86_64-macosx: define hidden zeroext i16 @"$s8abitypes3FooC20returnOtherEnumValue{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i16 zeroext) {{[#0-9]*}} { + // x86_64-macosx: define hidden zeroext i16 @"$s8abitypes3FooC20returnOtherEnumValue{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i16 zeroext %2) {{[#0-9]*}} { @objc dynamic func returnOtherEnumValue(_ choice: ChooseTo) -> ChooseTo { switch choice { case .takeIt: return .leaveIt @@ -482,8 +482,8 @@ class Foo { } } - // x86_64-macosx: define hidden swiftcc i32 @"$s8abitypes3FooC10getRawEnum{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself) {{.*}} { - // x86_64-macosx: define hidden i32 @"$s8abitypes3FooC10getRawEnum{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden swiftcc i32 @"$s8abitypes3FooC10getRawEnum{{[_0-9a-zA-Z]*}}F"(%T8abitypes3FooC* swiftself %0) {{.*}} { + // x86_64-macosx: define hidden i32 @"$s8abitypes3FooC10getRawEnum{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1) {{[#0-9]*}} { @objc dynamic func getRawEnum() -> RawEnum { return Intergalactic } @@ -493,7 +493,7 @@ class Foo { self.work = work } - // x86_64-macosx: define hidden void @"$s8abitypes3FooC13testArchetype{{[_0-9a-zA-Z]*}}FTo"(i8*, i8*, i8*) {{[#0-9]*}} { + // x86_64-macosx: define hidden void @"$s8abitypes3FooC13testArchetype{{[_0-9a-zA-Z]*}}FTo"(i8* %0, i8* %1, i8* %2) {{[#0-9]*}} { @objc dynamic func testArchetype(_ work: Work) { work.doStuff(1) // x86_64-macosx: [[OBJCPTR:%.*]] = bitcast i8* %2 to %objc_object* @@ -506,17 +506,17 @@ class Foo { return 1 } - // x86_64-macosx: define hidden swiftcc void @"$s8abitypes3FooC20testGenericTypeParam{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, %T8abitypes3FooC* swiftself) {{.*}} { + // x86_64-macosx: define hidden swiftcc void @"$s8abitypes3FooC20testGenericTypeParam{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T, %T8abitypes3FooC* swiftself %1) {{.*}} { func testGenericTypeParam(_ x: T) { // x86_64-macosx: [[CAST:%.*]] = bitcast %objc_object* %0 to i8* // x86_64-macosx: call void bitcast (void ()* @objc_msgSend to void (i8*, i8*)*)(i8* [[CAST]], i8* %{{.*}}) x.alDente() } - // arm64-ios: define hidden swiftcc { i64, i64, i64, i64 } @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, i64, i64, i64, i64, %T8abitypes3FooC* swiftself) {{.*}} { + // arm64-ios: define hidden swiftcc { i64, i64, i64, i64 } @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, i64 %1, i64 %2, i64 %3, i64 %4, %T8abitypes3FooC* swiftself %5) {{.*}} { // arm64-ios: define hidden void @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}FTo"(%TSo9BigStructV* noalias nocapture sret, i8*, i8*, [[OPAQUE:.*]]*, %TSo9BigStructV*) {{[#0-9]*}} { // - // arm64-tvos: define hidden swiftcc { i64, i64, i64, i64 } @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC*, i64, i64, i64, i64, %T8abitypes3FooC* swiftself) {{.*}} { + // arm64-tvos: define hidden swiftcc { i64, i64, i64, i64 } @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}F"(%TSo13StructReturnsC* %0, i64 %1, i64 %2, i64 %3, i64 %4, %T8abitypes3FooC* swiftself %5) {{.*}} { // arm64-tvos: define hidden void @"$s8abitypes3FooC14callJustReturn{{[_0-9a-zA-Z]*}}FTo"(%TSo9BigStructV* noalias nocapture sret, i8*, i8*, [[OPAQUE:.*]]*, %TSo9BigStructV*) {{[#0-9]*}} { @objc dynamic func callJustReturn(_ r: StructReturns, with v: BigStruct) -> BigStruct { return r.justReturn(v) @@ -534,7 +534,7 @@ class Foo { // armv7k-watchos: define internal %struct.One @makeOne(float %f, float %s) // rdar://17631440 - Expand direct arguments that are coerced to aggregates. -// x86_64-macosx: define{{( protected)?}} swiftcc float @"$s8abitypes13testInlineAggySfSo6MyRectVF"(float, float, float, float) {{.*}} { +// x86_64-macosx: define{{( protected)?}} swiftcc float @"$s8abitypes13testInlineAggySfSo6MyRectVF"(float %0, float %1, float %2, float %3) {{.*}} { // x86_64-macosx: [[COERCED:%.*]] = alloca %TSo6MyRectV, align 8 // x86_64-macosx: store float %0, // x86_64-macosx: store float %1, diff --git a/test/IRGen/alloc.sil b/test/IRGen/alloc.sil index 5a3a844717177..192d497f6ae28 100644 --- a/test/IRGen/alloc.sil +++ b/test/IRGen/alloc.sil @@ -19,6 +19,6 @@ struct Huge { var unalign: Builtin.Int8 } -// CHECK: define linkonce_odr hidden i8* @__swift_memcpy4097_8(i8*, i8*, %swift.type*) +// CHECK: define linkonce_odr hidden i8* @__swift_memcpy4097_8(i8* %0, i8* %1, %swift.type* %2) // CHECK: call void @llvm.memcpy.p0i8.p0i8.{{(i64|i32)}}(i8* align 8 %0, i8* align 8 %1, {{(i64|i32)}} 4097, i1 false) // CHECK: ret i8* %0 diff --git a/test/IRGen/alloc_stack.swift b/test/IRGen/alloc_stack.swift index 756e6e63e74db..d68f594251ed8 100644 --- a/test/IRGen/alloc_stack.swift +++ b/test/IRGen/alloc_stack.swift @@ -9,7 +9,7 @@ class Foobar { } // Make sure we are mis-initializing the alloca. -// CHECK-LABEL: define {{.*}}swiftcc %T11alloc_stack6FoobarC* @"$s11alloc_stack6FoobarCACycfc"(%T11alloc_stack6FoobarC* swiftself) +// CHECK-LABEL: define {{.*}}swiftcc %T11alloc_stack6FoobarC* @"$s11alloc_stack6FoobarCACycfc"(%T11alloc_stack6FoobarC* swiftself %0) // CHECK: alloca %TSb, align 1 // CHECK-NOT: store{{.*}}opaque // CHECK: ret {{.*}}%0 diff --git a/test/IRGen/archetype_resilience.sil b/test/IRGen/archetype_resilience.sil index eb27873c79b8d..475a795c33606 100644 --- a/test/IRGen/archetype_resilience.sil +++ b/test/IRGen/archetype_resilience.sil @@ -16,7 +16,7 @@ public enum EnumWithClassArchetypeAndDynamicSize { case B(Size) } -// CHECK-LABEL: define swiftcc void @copyDynamicMultiEnum(%swift.type* %"EnumWithClassArchetypeAndDynamicSize", %swift.type* %U, %T20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeO* noalias nocapture swiftself) +// CHECK-LABEL: define swiftcc void @copyDynamicMultiEnum(%swift.type* %"EnumWithClassArchetypeAndDynamicSize", %swift.type* %U, %T20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeO* noalias nocapture swiftself %0) // CHECK: call %T20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeO* @"$s20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeOyxGRlzCr0_lWOc"(%T20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeO* %0, %T20archetype_resilience36EnumWithClassArchetypeAndDynamicSizeO* {{.*}}, %swift.type* %"EnumWithClassArchetypeAndDynamicSize") // CHECK: ret void sil [ossa] @copyDynamicMultiEnum : $@convention(method) (@in_guaranteed EnumWithClassArchetypeAndDynamicSize) -> () { diff --git a/test/IRGen/argument_attrs.sil b/test/IRGen/argument_attrs.sil index 2db4522ef3bb3..40a6f3f5985a3 100644 --- a/test/IRGen/argument_attrs.sil +++ b/test/IRGen/argument_attrs.sil @@ -4,7 +4,7 @@ import Builtin struct Huge { var x, y, z, w, a, b, c, d, e, f: Builtin.Int32 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def(i32* nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40), %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def(i32* nocapture dereferenceable(4) %0, i32* noalias nocapture dereferenceable(4) %1, i32* noalias nocapture dereferenceable(4) %2, %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40) %3, %swift.opaque* noalias nocapture %4, %swift.opaque* noalias nocapture %5, %swift.type* %T) sil @arguments_in_def : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> () { entry(%1 : $*Builtin.Int32, %2 : $*Builtin.Int32, %3 : $*Builtin.Int32, %4 : $Huge, %5 : $*T, %6 : $*()): // CHECK: call swiftcc void @arguments_in_decl(i32* nocapture dereferenceable(4) {{%.*}}, i32* noalias nocapture dereferenceable(4) {{%.*}}, i32* noalias nocapture dereferenceable(4) {{%.*}}, %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40) {{%.*}}, %swift.opaque* noalias nocapture {{%.*}}, %swift.opaque* noalias nocapture {{%.*}}, %swift.type* %T) @@ -19,7 +19,7 @@ entry(%1 : $*Builtin.Int32, %2 : $*Builtin.Int32, %3 : $*Builtin.Int32, %4 : $Hu // CHECK-LABEL: declare{{( dllimport)?}} swiftcc void @arguments_in_decl(i32* nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40), %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*) sil @arguments_in_decl : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def_out(i32* noalias nocapture sret, i32* nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40), %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def_out(i32* noalias nocapture sret %0, i32* nocapture dereferenceable(4) %1, i32* noalias nocapture dereferenceable(4) %2, i32* noalias nocapture dereferenceable(4) %3, %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40) %4, %swift.opaque* noalias nocapture %5, %swift.opaque* noalias nocapture %6, %swift.type* %T) sil @arguments_in_def_out : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> @out Builtin.Int32 { entry(%0 : $*Builtin.Int32, %1 : $*Builtin.Int32, %2 : $*Builtin.Int32, %3 : $*Builtin.Int32, %4 : $Huge, %5 : $*T, %6 : $*()): // CHECK: call swiftcc void @arguments_in_decl_out(i32* noalias nocapture sret {{%.*}}, i32* nocapture dereferenceable(4) {{%.*}}, i32* noalias nocapture dereferenceable(4) {{%.*}}, i32* noalias nocapture dereferenceable(4) {{%.*}}, %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40) {{%.*}}, %swift.opaque* noalias nocapture {{%.*}}, %swift.opaque* noalias nocapture {{%.*}}, %swift.type* {{%.*}}) @@ -34,7 +34,7 @@ entry(%0 : $*Builtin.Int32, %1 : $*Builtin.Int32, %2 : $*Builtin.Int32, %3 : $*B // CHECK-LABEL: declare{{( dllimport)?}} swiftcc void @arguments_in_decl_out(i32* noalias nocapture sret, i32* nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40), %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*) sil @arguments_in_decl_out : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> @out Builtin.Int32 -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def_huge_ret(%T14argument_attrs4HugeV* noalias nocapture sret, i32* nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), i32* noalias nocapture dereferenceable(4), %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40), %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @arguments_in_def_huge_ret(%T14argument_attrs4HugeV* noalias nocapture sret %0, i32* nocapture dereferenceable(4) %1, i32* noalias nocapture dereferenceable(4) %2, i32* noalias nocapture dereferenceable(4) %3, %T14argument_attrs4HugeV* noalias nocapture dereferenceable(40) %4, %swift.opaque* noalias nocapture %5, %swift.opaque* noalias nocapture %6, %swift.type* %T) sil @arguments_in_def_huge_ret : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> Huge { entry(%1 : $*Builtin.Int32, %2 : $*Builtin.Int32, %3 : $*Builtin.Int32, %4 : $Huge, %5 : $*T, %6 : $*()): %f = function_ref @arguments_in_decl_huge_ret : $@convention(thin) (@inout Builtin.Int32, @in Builtin.Int32, @in_guaranteed Builtin.Int32, Huge, @in T, @in ()) -> Huge diff --git a/test/IRGen/associated_type_witness.swift b/test/IRGen/associated_type_witness.swift index 9342c8ba5addb..298756bdb66db 100644 --- a/test/IRGen/associated_type_witness.swift +++ b/test/IRGen/associated_type_witness.swift @@ -98,7 +98,7 @@ struct Computed : Assocked { } // Instantiation function for GenericComputed : DerivedFromSimpleAssoc. -// CHECK-LABEL: define internal void @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWI"(i8**, %swift.type* %"GenericComputed", i8**) +// CHECK-LABEL: define internal void @"$s23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWI"(i8** %0, %swift.type* %"GenericComputed", i8** %1) // CHECK: [[T0:%.*]] = call i8** @swift_getWitnessTable({{.*}}@"$s23associated_type_witness15GenericComputedVyxGAA14HasSimpleAssocAAMc" // CHECK-NEXT: [[T1:%.*]] = bitcast i8** [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8*, i8** %0, i32 1 diff --git a/test/IRGen/associated_types.swift b/test/IRGen/associated_types.swift index 85039ee87535a..5d0953f1a0e6c 100644 --- a/test/IRGen/associated_types.swift +++ b/test/IRGen/associated_types.swift @@ -30,7 +30,7 @@ struct Owl { class Pussycat { init() {} - // CHECK: define hidden swiftcc void @"$s16associated_types8PussycatC3eat{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %T16associated_types8PussycatC* swiftself) + // CHECK: define hidden swiftcc void @"$s16associated_types8PussycatC3eat{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %T16associated_types8PussycatC* swiftself %3) func eat(_ what: T.RuncerType.Runcee, and: T.RuncerType, with: T) { } } @@ -71,7 +71,7 @@ func testFastRuncible(_ t: T, u: U) U.RuncerType.Runcee.accelerate() } -// CHECK: define hidden swiftcc void @"$s16associated_types16testFastRuncible_1uyx_q_tAA0E0RzAA0dE0R_10RuncerTypeQy_AFRtzr0_lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T, %swift.type* %U, i8** %T.Runcible, i8** %U.FastRuncible) #0 { +// CHECK: define hidden swiftcc void @"$s16associated_types16testFastRuncible_1uyx_q_tAA0E0RzAA0dE0R_10RuncerTypeQy_AFRtzr0_lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, %swift.type* %U, i8** %T.Runcible, i8** %U.FastRuncible) {{.*}} { // 1. Get the type metadata for U.RuncerType.Runcee. // 1a. Get the type metadata for U.RuncerType. // Note that we actually look things up in T, which is going to prove unfortunate. diff --git a/test/IRGen/assume.sil b/test/IRGen/assume.sil index 5a45b0e38d9ba..9ecdf58d96930 100644 --- a/test/IRGen/assume.sil +++ b/test/IRGen/assume.sil @@ -4,7 +4,7 @@ sil_stage canonical import Swift import Builtin -// CHECK-LABEL: define{{.*}} swiftcc i64 @test_assume(i64) +// CHECK-LABEL: define{{.*}} swiftcc i64 @test_assume(i64 %0) // CHECK: [[COND:%.*]] = icmp sgt i64 %0, -1 // CHECK: tail call void @llvm.assume(i1 [[COND]]) // CHECK: [[RES:%.*]] = lshr i64 %0, 6 diff --git a/test/IRGen/autolink-force-link.swift b/test/IRGen/autolink-force-link.swift index a90730717e4dd..9c876fd2d9de9 100644 --- a/test/IRGen/autolink-force-link.swift +++ b/test/IRGen/autolink-force-link.swift @@ -2,16 +2,16 @@ // RUN: %swift -disable-legacy-type-info -target x86_64-apple-macosx10.9 -parse-stdlib -autolink-force-load -module-name TEST -module-link-name TEST -emit-ir %s %S/../Inputs/empty.swift | %FileCheck -check-prefix=CHECK-WMO %s -// CHECK-WMO: source_filename = "-" +// CHECK-WMO: source_filename = "" // CHECK-WMO: define void @"_swift_FORCE_LOAD_$_TEST"() // CHECK-WMO-NOT: source_filename // RUN: %swift -disable-legacy-type-info -target x86_64-apple-macosx10.9 -parse-stdlib -autolink-force-load -module-name TEST -module-link-name TEST -emit-ir -num-threads 1 %s %S/../Inputs/empty.swift | %FileCheck -check-prefix=CHECK-WMO-THREADED %s -// CHECK-WMO-THREADED: source_filename = "-" +// CHECK-WMO-THREADED: source_filename = "" // CHECK-WMO-THREADED: define void @"_swift_FORCE_LOAD_$_TEST"() -// CHECK-WMO-THREADED: source_filename = "-" +// CHECK-WMO-THREADED: source_filename = "" // CHECK-WMO-THREADED-NOT: _swift_FORCE_LOAD_$_TEST // CHECK-WMO-THREADED-NOT: source_filename @@ -19,11 +19,11 @@ // RUN: %swift -disable-legacy-type-info -target x86_64-apple-macosx10.9 -parse-stdlib -autolink-force-load -module-name TEST -module-link-name TEST -emit-ir -primary-file %s %S/../Inputs/empty.swift | %FileCheck -check-prefix=CHECK-SINGLE-FILE-FIRST %s // RUN: %swift -disable-legacy-type-info -target x86_64-apple-macosx10.9 -parse-stdlib -autolink-force-load -module-name TEST -module-link-name TEST -emit-ir %S/../Inputs/empty.swift -primary-file %s | %FileCheck -check-prefix=CHECK-SINGLE-FILE-SECOND %s -// CHECK-SINGLE-FILE-FIRST: source_filename = "-" +// CHECK-SINGLE-FILE-FIRST: source_filename = "" // CHECK-SINGLE-FILE-FIRST: define void @"_swift_FORCE_LOAD_$_TEST"() // CHECK-SINGLE-FILE-FIRST-NOT: source_filename -// CHECK-SINGLE-FILE-SECOND: source_filename = "-" +// CHECK-SINGLE-FILE-SECOND: source_filename = "" // CHECK-SINGLE-FILE-SECOND-NOT: _swift_FORCE_LOAD_$_TEST // CHECK-SINGLE-FILE-SECOND-NOT: source_filename diff --git a/test/IRGen/autorelease.sil b/test/IRGen/autorelease.sil index 00b7d9251085c..223cc89e49417 100644 --- a/test/IRGen/autorelease.sil +++ b/test/IRGen/autorelease.sil @@ -18,7 +18,7 @@ bb0(%0 : @owned $C?): return %0 : $C? } -// CHECK: define{{( dllexport| protected)?}} swiftcc [[INT]] @foo([[INT]]) {{.*}} { +// CHECK: define{{( dllexport| protected)?}} swiftcc [[INT]] @foo([[INT]] %0) {{.*}} { // CHECK: [[T0:%.*]] = inttoptr [[INT]] %0 to i8* // CHECK-NEXT: [[T1:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T0]]) // CHECK-NEXT: [[T2:%.*]] = ptrtoint i8* [[T1]] to [[INT]] @@ -31,14 +31,14 @@ bb0(%0 : @owned $C?): return %2 : $C? } -// x86_64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64) +// x86_64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64 %0) // x86_64: [[T0:%.*]] = call swiftcc i64 @foo(i64 %0) // x86_64-NEXT: [[T1:%.*]] = inttoptr i64 [[T0]] to i8* // x86_64-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]]) // x86_64-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i64 // x86_64-NEXT: ret i64 [[T3]] -// arm64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64) +// arm64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64 %0) // arm64: [[T0:%.*]] = call swiftcc i64 @foo(i64 %0) // arm64-NEXT: call void asm sideeffect "mov // arm64-NEXT: [[T1:%.*]] = inttoptr i64 [[T0]] to i8* @@ -46,7 +46,7 @@ bb0(%0 : @owned $C?): // arm64-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i64 // arm64-NEXT: ret i64 [[T3]] -// aarch64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64) +// aarch64: define{{( dllexport| protected)?}} swiftcc i64 @bar(i64 %0) // aarch64: [[T0:%.*]] = call swiftcc i64 @foo(i64 %0) // aarch64-NEXT: call void asm sideeffect "mov // aarch64-NEXT: [[T1:%.*]] = inttoptr i64 [[T0]] to i8* @@ -54,14 +54,14 @@ bb0(%0 : @owned $C?): // aarch64-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i64 // aarch64-NEXT: ret i64 [[T3]] -// i386: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32) +// i386: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32 %0) // i386: [[T0:%.*]] = call swiftcc i32 @foo(i32 %0) // i386-NEXT: [[T1:%.*]] = inttoptr i32 [[T0]] to i8* // i386-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]]) // i386-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i32 // i386-NEXT: ret i32 [[T3]] -// armv7: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32) +// armv7: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32 %0) // armv7: [[T0:%.*]] = call swiftcc i32 @foo(i32 %0) // armv7-NEXT: call void asm sideeffect "mov // armv7-NEXT: [[T1:%.*]] = inttoptr i32 [[T0]] to i8* @@ -69,7 +69,7 @@ bb0(%0 : @owned $C?): // armv7-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i32 // armv7-NEXT: ret i32 [[T3]] -// armv7s: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32) +// armv7s: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32 %0) // armv7s: [[T0:%.*]] = call swiftcc i32 @foo(i32 %0) // armv7s-NEXT: call void asm sideeffect "mov // armv7s-NEXT: [[T1:%.*]] = inttoptr i32 [[T0]] to i8* @@ -77,7 +77,7 @@ bb0(%0 : @owned $C?): // armv7s-NEXT: [[T3:%.*]] = ptrtoint i8* [[T2]] to i32 // armv7s-NEXT: ret i32 [[T3]] -// armv7k: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32) +// armv7k: define{{( dllexport| protected)?}} swiftcc i32 @bar(i32 %0) // armv7k: [[T0:%.*]] = call swiftcc i32 @foo(i32 %0) // armv7k-NEXT: call void asm sideeffect "mov // armv7k-NEXT: [[T1:%.*]] = inttoptr i32 [[T0]] to i8* diff --git a/test/IRGen/big_types_corner_cases.sil b/test/IRGen/big_types_corner_cases.sil index 48bbe017a41e9..115025d645764 100644 --- a/test/IRGen/big_types_corner_cases.sil +++ b/test/IRGen/big_types_corner_cases.sil @@ -53,7 +53,7 @@ entry(%b : $(BitfieldOne, @convention(block) (BitfieldOne) -> (BitfieldOne)), %x return %r : $BitfieldOne } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testBigTempStruct(%T22big_types_corner_cases13BigTempStructV* noalias nocapture sret, %swift.bridge*, %swift.type* %Element) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testBigTempStruct(%T22big_types_corner_cases13BigTempStructV* noalias nocapture sret %0, %swift.bridge* %1, %swift.type* %Element) // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases13BigTempStructV // CHECK: call swiftcc void @testBigTempStruct(%T22big_types_corner_cases13BigTempStructV* noalias nocapture sret [[ALLOC]], %swift.bridge* %1, %swift.type* %Element) // CHECK: ret void @@ -65,7 +65,7 @@ bb0(%0 : $_ArrayBuffer): return %9 : $BigTempStruct } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testTryApply(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, i8*, %swift.refcounted*, %swift.refcounted* swiftself, %swift.error** noalias nocapture swifterror dereferenceable(8)) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testTryApply(%T22big_types_corner_cases9BigStructV* noalias nocapture sret %0, i8* %1, %swift.refcounted* %2, %swift.refcounted* swiftself %3, %swift.error** noalias nocapture swifterror dereferenceable(8) %4) // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructV // CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructV* noalias nocapture sret [[ALLOC]] // CHECK: ret void @@ -92,7 +92,7 @@ bb0(%0 : $BigTempStruct): return %ret : $Builtin.RawPointer } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testFuncWithModBlockStorageApply({ %objc_block, %swift.function }* nocapture dereferenceable({{.*}}), %T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testFuncWithModBlockStorageApply({ %objc_block, %swift.function }* nocapture dereferenceable({{.*}}) %0, %T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) // CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %1 // CHECK: ret void sil @testFuncWithModBlockStorageApply : $@convention(thin) (@inout_aliasable @block_storage @callee_owned (@owned BigStruct) -> (), BigStruct) -> () { @@ -119,7 +119,7 @@ sil public_external @c_return_func : $@convention(thin) () -> () -> @owned BigSt // CHECK: [[RET:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%T22big_types_corner_cases9BigStructV*, i64, %swift.refcounted*)* @"$s17part_apply_calleeTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* // CHECK: ret { i8*, %swift.refcounted* } [[RET]] -// CHECK-LABEL: define internal swiftcc void @"$s17part_apply_calleeTA"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, i64, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s17part_apply_calleeTA"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret %0, i64 %1, %swift.refcounted* swiftself %2) // CHECK: bitcast %swift.refcounted* %2 to <{ %swift.refcounted, %swift.function }>* // CHECK: ret void @@ -137,7 +137,7 @@ bb0(%0 : $Builtin.Int64, %1 : $() -> @owned BigStruct): return undef : $BigStruct } -// CHECK-LABEL: define swiftcc void @poninter_to_mod_ret(i8*, %swift.refcounted*) +// CHECK-LABEL: define swiftcc void @poninter_to_mod_ret(i8* %0, %swift.refcounted* %1) // CHECK: [[BITCAST:%.*]] = bitcast i8* %0 to { i8*, %swift.refcounted* } (%swift.refcounted*)* // CHECK: [[CALL:%.*]] = call swiftcc { i8*, %swift.refcounted* } [[BITCAST]](%swift.refcounted* swiftself %1) // CHECK: extractvalue { i8*, %swift.refcounted* } [[CALL]], 0 @@ -186,7 +186,7 @@ sil @get_optional_none : $@convention(method) <τ_0_0> (@thin Optional<τ_0_0>.T sil @short_circuit_operation : $@convention(thin) <τ_0_0> (@in Optional<τ_0_0>, @owned @callee_owned () -> (@out τ_0_0, @error Error)) -> (@out τ_0_0, @error Error) sil @autoclosure_partialapply : $@convention(thin) (@owned @callee_owned () -> (BigStruct, @error Error)) -> (@out BigStruct, @error Error) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @closure(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, %T22big_types_corner_cases8SuperSubC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @closure(%T22big_types_corner_cases9BigStructV* noalias nocapture sret %0, %T22big_types_corner_cases8SuperSubC* %1) // CHECK-64: [[ALLOC1:%.*]] = alloca %T22big_types_corner_cases9BigStructV // CHECK-64: [[ALLOC2:%.*]] = alloca %T22big_types_corner_cases9BigStructV // CHECK-64: [[ALLOC3:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg @@ -258,7 +258,7 @@ bb0: sil @convertToThickHelper : $@convention(thin) (@owned BigStruct) -> () -// CHECK-LABAL: define {{.*}} swiftcc void @convertToThick(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABAL: define {{.*}} swiftcc void @convertToThick(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %0) // CHECK: entry: // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructV, align 4 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64 @@ -296,7 +296,7 @@ bb0(%1 : $X): sil @$getLargeObjCType : $@convention(thin) () -> BitfieldOne -// CHECK-LABAL: define {{.*}} swiftcc void @"$crash_on_objc_apply"(%objc_object*) +// CHECK-LABAL: define {{.*}} swiftcc void @"$crash_on_objc_apply"(%objc_object* %0) // CHECK: entry: // CHECK: [[LOADS:%.*]] = load i8*, i8** @"\01L_selector(foo)" // CHECK: [[RESS:%.*]] = load i8*, i8** @"\01L_selector(respondsToSelector:)" @@ -334,7 +334,7 @@ bb3: // Preds: bb2 bb1 sil @slowCallee : $@convention(thin) (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed Array) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned @callee_guaranteed (@guaranteed String) -> @owned BigStruct -// CHECK-LABAL: define {{.*}} swiftcc void @slowCaller(i64, %swift.bridge*) +// CHECK-LABAL: define {{.*}} swiftcc void @slowCaller(i64 %0, %swift.bridge* %1) // CHECK: call swiftcc { i8*, %swift.refcounted* } @slowCallee(i64 %0, %swift.bridge* %1) sil @slowCaller : $@convention(thin) (@guaranteed String) -> () { bb0(%0 : $String): diff --git a/test/IRGen/big_types_corner_cases.swift b/test/IRGen/big_types_corner_cases.swift index 0520bbd6cc7bf..57188b02cb4fa 100644 --- a/test/IRGen/big_types_corner_cases.swift +++ b/test/IRGen/big_types_corner_cases.swift @@ -37,7 +37,7 @@ class OptionalInoutFuncType { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} i32 @main(i32, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} i32 @main(i32 %0, i8** %1) // CHECK: call void @llvm.lifetime.start // CHECK: call void @llvm.memcpy // CHECK: call void @llvm.lifetime.end @@ -46,7 +46,7 @@ let bigStructGlobalArray : [BigStruct] = [ BigStruct() ] -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc void @"$s22big_types_corner_cases21OptionalInoutFuncTypeC7executeyys5Error_pSgFyyXEfU_"(%T22big_types_corner_cases9BigStructVSg* nocapture dereferenceable({{.*}}), %T22big_types_corner_cases21OptionalInoutFuncTypeC*, %T22big_types_corner_cases9BigStructVSgs5Error_pSgIegcg_Sg* nocapture dereferenceable({{.*}}) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc void @"$s22big_types_corner_cases21OptionalInoutFuncTypeC7executeyys5Error_pSgFyyXEfU_"(%T22big_types_corner_cases9BigStructVSg* nocapture dereferenceable({{.*}}) %0, %T22big_types_corner_cases21OptionalInoutFuncTypeC* %1, %T22big_types_corner_cases9BigStructVSgs5Error_pSgIegcg_Sg* nocapture dereferenceable({{.*}}) // CHECK: call void @"$s22big_types_corner_cases9BigStructVSgs5Error_pSgIegcg_SgWOe // CHECK: call void @"$s22big_types_corner_cases9BigStructVSgs5Error_pSgIegcg_SgWOy // CHECK: ret void @@ -96,7 +96,7 @@ public class BigClass { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases8BigClassC03useE6Struct0aH0yAA0eH0V_tF"(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}), %T22big_types_corner_cases8BigClassC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases8BigClassC03useE6Struct0aH0yAA0eH0V_tF"(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %0, %T22big_types_corner_cases8BigClassC* swiftself %1) // CHECK: [[BITCAST:%.*]] = bitcast i8* {{.*}} to void (%T22big_types_corner_cases9BigStructV*, %swift.refcounted*)* // CHECK: call swiftcc void [[BITCAST]](%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %0, %swift.refcounted* swiftself // CHECK: ret void @@ -117,7 +117,7 @@ class Foo { func myMethod(_ callback: (MyStruct, Int) -> Void) -> Void { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden swiftcc { i8*, %swift.refcounted* } @"$s22big_types_corner_cases3FooC8myMethodyyyAA8MyStructV_SitXEFTc"(%T22big_types_corner_cases3FooC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden swiftcc { i8*, %swift.refcounted* } @"$s22big_types_corner_cases3FooC8myMethodyyyAA8MyStructV_SitXEFTc"(%T22big_types_corner_cases3FooC* %0) // CHECK: getelementptr inbounds %T22big_types_corner_cases3FooC, %T22big_types_corner_cases3FooC* // CHECK: getelementptr inbounds void (i8*, %swift.opaque*, %T22big_types_corner_cases3FooC*)*, void (i8*, %swift.opaque*, %T22big_types_corner_cases3FooC*)** // CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @@ -140,7 +140,7 @@ public func enumCallee(_ x: LargeEnum) { case .Empty2: break } } -// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases10enumCalleeyAA9LargeEnumOF"(%T22big_types_corner_cases9LargeEnumO* noalias nocapture dereferenceable({{.*}})) #0 { +// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases10enumCalleeyAA9LargeEnumOF"(%T22big_types_corner_cases9LargeEnumO* noalias nocapture dereferenceable({{.*}}) %0) #0 { // CHECK-64: alloca %T22big_types_corner_cases9LargeEnumO05InnerF0O // CHECK-64: alloca %T22big_types_corner_cases9LargeEnumO // CHECK-64: call void @llvm.memcpy.p0i8.p0i8.i64 @@ -148,7 +148,7 @@ public func enumCallee(_ x: LargeEnum) { // CHECK-64: $ss5print_9separator10terminatoryypd_S2StF // CHECK-64: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc void @"$s22big_types_corner_cases8SuperSubC1fyyFAA9BigStructVycfU_"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, %T22big_types_corner_cases8SuperSubC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc void @"$s22big_types_corner_cases8SuperSubC1fyyFAA9BigStructVycfU_"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret %0, %T22big_types_corner_cases8SuperSubC* %1) // CHECK-64: [[ALLOC1:%.*]] = alloca %T22big_types_corner_cases9BigStructV // CHECK-64: [[ALLOC2:%.*]] = alloca %T22big_types_corner_cases9BigStructV // CHECK-64: [[ALLOC3:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg @@ -171,7 +171,7 @@ class SuperSub : SuperBase { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases10MUseStructV16superclassMirrorAA03BigF0VSgvg"(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret, %T22big_types_corner_cases10MUseStructV* noalias nocapture swiftself dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases10MUseStructV16superclassMirrorAA03BigF0VSgvg"(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret %0, %T22big_types_corner_cases10MUseStructV* noalias nocapture swiftself dereferenceable({{.*}}) %1) // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg // CHECK: [[LOAD:%.*]] = load %swift.refcounted*, %swift.refcounted** %.callInternalLet.data // CHECK: call swiftcc void %7(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret [[ALLOC]], %swift.refcounted* swiftself [[LOAD]]) @@ -185,8 +185,8 @@ public struct MUseStruct { internal let callInternalLet: () -> BigStruct? } -// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, %Ts9SubstringV }>* noalias nocapture sret) #0 { -// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, [4 x i8], %Ts9SubstringV }>* noalias nocapture sret) #0 { +// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, %Ts9SubstringV }>* noalias nocapture sret %0) #0 { +// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, [4 x i8], %Ts9SubstringV }>* noalias nocapture sret %0) #0 { // CHECK: alloca %TSs // CHECK: alloca %TSs // CHECK: ret void @@ -206,13 +206,13 @@ public func testGetFunc() { let testGetPtr: @convention(thin) () -> BigStruct = bigStructGet } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases7TestBigC4testyyF"(%T22big_types_corner_cases7TestBigC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases7TestBigC4testyyF"(%T22big_types_corner_cases7TestBigC* swiftself %0) // CHECK: [[CALL1:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$sSayy22big_types_corner_cases9BigStructVcSgGMD" // CHECK: [[CALL2:%.*]] = call i8** @"$sSayy22big_types_corner_cases9BigStructVcSgGSayxGSlsWl // CHECK: call swiftcc void @"$sSlsE10firstIndex5where0B0QzSgSb7ElementQzKXE_tKF"(%TSq.{{.*}}* noalias nocapture sret {{.*}}, i8* bitcast (i1 (%T22big_types_corner_cases9BigStructVytIegnr_Sg*, %swift.refcounted*, %swift.error**)* @"$s22big_types_corner_cases9BigStructVIegy_SgSbs5Error_pIggdzo_ACytIegnr_SgSbsAE_pIegndzo_TRTA" to i8*), %swift.opaque* {{.*}}, %swift.type* [[CALL1]], i8** [[CALL2]], %swift.opaque* noalias nocapture swiftself // CHECK: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases7TestBigC5test2yyF"(%T22big_types_corner_cases7TestBigC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases7TestBigC5test2yyF"(%T22big_types_corner_cases7TestBigC* swiftself %0) // CHECK: [[CALL1:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$sSaySS2ID_y22big_types_corner_cases9BigStructVcSg7handlertGMD" // CHECK: [[CALL2:%.*]] = call i8** @"$sSaySS2ID_y22big_types_corner_cases9BigStructVcSg7handlertGSayxGSlsWl" // CHECK: call swiftcc void @"$sSlss16IndexingIteratorVyxG0B0RtzrlE04makeB0ACyF"(%Ts16IndexingIteratorV{{.*}}* noalias nocapture sret {{.*}}, %swift.type* [[CALL1]], i8** [[CALL2]], %swift.opaque* noalias nocapture swiftself {{.*}}) @@ -240,7 +240,7 @@ struct BigStructWithFunc { var foo: ((BigStruct) -> Void)? } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases20UseBigStructWithFuncC5crashyyF"(%T22big_types_corner_cases20UseBigStructWithFuncC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} hidden swiftcc void @"$s22big_types_corner_cases20UseBigStructWithFuncC5crashyyF"(%T22big_types_corner_cases20UseBigStructWithFuncC* swiftself %0) // CHECK: call swiftcc void @"$s22big_types_corner_cases20UseBigStructWithFuncC10callMethod // CHECK: ret void class UseBigStructWithFunc { @@ -299,7 +299,7 @@ public protocol sr8076_QueryHandler: sr8076_ProtoQueryHandler { public extension sr8076_QueryHandler { -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_15queryyqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_15queryyqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture %0, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %1) // CHECK: call swiftcc void {{.*}}(%swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}) // CHECK: ret void func forceHandle_1(query: Q) -> Void { @@ -309,7 +309,7 @@ public extension sr8076_QueryHandler { body(query) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_25query8ReturnedQyd___AA9BigStructVSgtqd___tAA0e1_F0Rd__lF"(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_25query8ReturnedQyd___AA9BigStructVSgtqd___tAA0e1_F0Rd__lF"(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %3) // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg // CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret [[ALLOC]], %swift.opaque* noalias nocapture {{.*}}, %swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}) // CHECK: ret void @@ -320,11 +320,11 @@ public extension sr8076_QueryHandler { return body(query) } -// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_35query8ReturnedQyd___SbAA9BigStructVcSgtqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself) +// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_35query8ReturnedQyd___SbAA9BigStructVcSgtqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %2) // CHECK-64: {{.*}} = call swiftcc { i64, i64 } {{.*}}(%swift.opaque* noalias nocapture {{.*}}, %swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}) // CHECK-64: ret { i64, i64 } -// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32} @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_35query8ReturnedQyd___SbAA9BigStructVcSgtqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself) +// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32} @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_35query8ReturnedQyd___SbAA9BigStructVcSgtqd___tAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %2) // CHECK-32: {{.*}} = call swiftcc { i32, i32 } {{.*}}(%swift.opaque* noalias nocapture {{.*}}, %swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}) // CHECK-32: ret { i32, i32 } func forceHandle_3(query: Q) -> (Q.Returned, sr8076_Filter?) { @@ -334,11 +334,11 @@ public extension sr8076_QueryHandler { return body(query) } -// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_45query8ReturnedQyd___SbAA9BigStructVcSgtqd___tKAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself, %swift.error** swifterror) +// CHECK-LABEL-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_45query8ReturnedQyd___SbAA9BigStructVcSgtqd___tKAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %2, %swift.error** swifterror %3) // CHECK-64: {{.*}} = call swiftcc { i64, i64 } {{.*}}(%swift.opaque* noalias nocapture {{.*}}, %swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}, %swift.error** noalias nocapture swifterror {{.*}}) // CHECK-64: ret { i64, i64 } -// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32} @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_45query8ReturnedQyd___SbAA9BigStructVcSgtqd___tKAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself, %swift.error** swifterror) +// CHECK-LABEL-32: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32} @"$s22big_types_corner_cases19sr8076_QueryHandlerPAAE13forceHandle_45query8ReturnedQyd___SbAA9BigStructVcSgtqd___tKAA0e1_F0Rd__lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type*{{.*}}, %swift.type*{{.*}}, i8** {{.*}}.sr8076_QueryHandler, i8** {{.*}}.sr8076_Query, %swift.opaque* noalias nocapture swiftself %2, %swift.error** swifterror %3) // CHECK-32: {{.*}} = call swiftcc { i32, i32 } {{.*}}(%swift.opaque* noalias nocapture {{.*}}, %swift.opaque* noalias nocapture {{.*}}, %swift.refcounted* swiftself {{.*}}, %swift.error** noalias nocapture {{.*}}) // CHECK-32: ret { i32, i32 } func forceHandle_4(query: Q) throws -> (Q.Returned, sr8076_Filter?) { diff --git a/test/IRGen/bitcast.sil b/test/IRGen/bitcast.sil index 5966e000cc729..e596affcec57e 100644 --- a/test/IRGen/bitcast.sil +++ b/test/IRGen/bitcast.sil @@ -16,7 +16,7 @@ sil_vtable C {} protocol CP: class {} -// CHECK-i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @bitcast_trivial(%T7bitcast1CC*) {{.*}} { +// CHECK-i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @bitcast_trivial(%T7bitcast1CC* %0) {{.*}} { // CHECK-i386: [[BUF:%.*]] = alloca %T7bitcast1CC*, align 4 // CHECK-i386: store %T7bitcast1CC* %0, %T7bitcast1CC** [[BUF]] // CHECK-i386: [[OUT_BUF:%.*]] = bitcast %T7bitcast1CC** [[BUF]] to %TSi* @@ -25,7 +25,7 @@ protocol CP: class {} // CHECK-i386: ret i32 [[VALUE]] // CHECK-i386: } -// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @bitcast_trivial(%T7bitcast1CC*) {{.*}} { +// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @bitcast_trivial(%T7bitcast1CC* %0) {{.*}} { // CHECK-x86_64: [[BUF:%.*]] = alloca %T7bitcast1CC*, align 8 // CHECK-x86_64: store %T7bitcast1CC* %0, %T7bitcast1CC** [[BUF]] // CHECK-x86_64: [[OUT_BUF:%.*]] = bitcast %T7bitcast1CC** [[BUF]] to %TSi* @@ -40,7 +40,7 @@ entry(%c : $C): } -// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @bitcast_trivial_optional(i64, i8) {{.*}} { +// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @bitcast_trivial_optional(i64 %0, i8 %1) {{.*}} { // CHECK-x86_64-NEXT: entry: // CHECK-x86_64-NEXT: %2 = trunc i8 %1 to i1 // CHECK-x86_64-NEXT: %3 = zext i1 %2 to i8 @@ -54,13 +54,13 @@ entry(%c : $Optional): return %i : $Optional } -// CHECK-i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @bitcast_ref(%T7bitcast1CC*) {{.*}} { +// CHECK-i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @bitcast_ref(%T7bitcast1CC* %0) {{.*}} { // CHECK-i386-NEXT: entry: // CHECK-i386-NEXT: [[VALUE:%.*]] = ptrtoint %T7bitcast1CC* %0 to i32 // CHECK-i386-NEXT: ret i32 [[VALUE]] // CHECK-i386-NEXT: } -// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @bitcast_ref(%T7bitcast1CC*) {{.*}} { +// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @bitcast_ref(%T7bitcast1CC* %0) {{.*}} { // CHECK-x86_64-NEXT: entry: // CHECK-x86_64-NEXT: [[VALUE:%.*]] = ptrtoint %T7bitcast1CC* %0 to i64 // CHECK-x86_64-NEXT: ret i64 [[VALUE]] @@ -71,12 +71,12 @@ entry(%c : $C): return %o : $Optional } -// CHECK-i386-LABEL: define hidden swiftcc i32 @bitcast_ref_optional(i32) {{.*}} { +// CHECK-i386-LABEL: define hidden swiftcc i32 @bitcast_ref_optional(i32 %0) {{.*}} { // CHECK-i386-NEXT: entry: // CHECK-i386-NEXT: ret i32 %0 // CHECK-i386-NEXT: } -// CHECK-x86_64-LABEL: define hidden swiftcc i64 @bitcast_ref_optional(i64) {{.*}} { +// CHECK-x86_64-LABEL: define hidden swiftcc i64 @bitcast_ref_optional(i64 %0) {{.*}} { // CHECK-x86_64-NEXT: entry: // CHECK-x86_64-NEXT: ret i64 %0 // CHECK-x86_64-NEXT: } @@ -86,7 +86,7 @@ bb0(%0 : $Optional): return %o : $Optional } -// CHECK-x86_64-LABEL: define hidden swiftcc i64 @unchecked_bitwise_cast(i64, i64) {{.*}} { +// CHECK-x86_64-LABEL: define hidden swiftcc i64 @unchecked_bitwise_cast(i64 %0, i64 %1) {{.*}} { // CHECK-x86_64-NEXT: entry: // CHECK-x86_64-NEXT: alloca <{ %TSi, %TSi }>, align 8 // A bunch of GEPs happen here to get from Int to int. @@ -104,7 +104,7 @@ bb0(%0 : $Int, %1 : $Int): return %3 : $Int } -// CHECK-x86_64-LABEL: define hidden swiftcc i64 @trivial_bitwise_cast(i64, i64) {{.*}} { +// CHECK-x86_64-LABEL: define hidden swiftcc i64 @trivial_bitwise_cast(i64 %0, i64 %1) {{.*}} { // CHECK-x86_64-NOT: trap // CHECK-x86_64-NOT: unreachable // CHECK-x86_64: bitcast <{ %TSi, %TSi }>* %bitcast to %TSi* diff --git a/test/IRGen/bitcast_different_size.sil b/test/IRGen/bitcast_different_size.sil index fbe8d79cdc30a..3535381d54f87 100644 --- a/test/IRGen/bitcast_different_size.sil +++ b/test/IRGen/bitcast_different_size.sil @@ -9,7 +9,7 @@ import Swift // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @bitcast_different_size1 -// OPT-LABEL: define{{.*}}@bitcast_different_size1(i32) +// OPT-LABEL: define{{.*}}@bitcast_different_size1(i32 %0) // OPT: tail call void asm sideeffect "", "n"(i32 0) // OPT-NEXT: tail call void @llvm.trap() // OPT-NEXT: unreachable diff --git a/test/IRGen/boxed_existential.sil b/test/IRGen/boxed_existential.sil index a6219815c2cc2..2f3d5ec0149e9 100644 --- a/test/IRGen/boxed_existential.sil +++ b/test/IRGen/boxed_existential.sil @@ -4,7 +4,7 @@ import Swift sil @error_user : $@convention(thin) (@owned Error) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @retain_release_boxed_existential(%swift.error*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @retain_release_boxed_existential(%swift.error* %0) sil @retain_release_boxed_existential : $@convention(thin) (@owned Error) -> () { entry(%e : $Error): // CHECK-objc: @swift_errorRetain @@ -18,7 +18,7 @@ entry(%e : $Error): return undef : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.Error) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.Error) sil @alloc_boxed_existential : $@convention(thin) (@in T) -> @owned Error { entry(%x : $*T): // CHECK: [[BOX_PAIR:%.*]] = call swiftcc { %swift.error*, %swift.opaque* } @swift_allocError(%swift.type* %T, i8** %T.Error, %swift.opaque* null, i1 false) @@ -51,7 +51,7 @@ entry(%x : $SomeError): return %b : $Error } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_boxed_existential(%swift.error*, %swift.type* %T, i8** %T.Error) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_boxed_existential(%swift.error* %0, %swift.type* %T, i8** %T.Error) sil @dealloc_boxed_existential : $@convention(thin) (@owned Error) -> () { entry(%b : $Error): // CHECK: call void @swift_deallocError(%swift.error* %0, %swift.type* %T) @@ -72,7 +72,7 @@ bb0: return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i[0-9]+}} @project_boxed_existential(%swift.error*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i[0-9]+}} @project_boxed_existential(%swift.error* %0) sil @project_boxed_existential : $@convention(thin) (@owned Error) -> Int { entry(%b : $Error): // CHECK: call void @swift_getErrorValue(%swift.error* %0, i8** {{%.*}}, [[TRIPLE:{ %swift.opaque\*, %swift.type\*, i8\*\* }]]* [[OUT:%.*]]) diff --git a/test/IRGen/builtin_vector.sil b/test/IRGen/builtin_vector.sil index 25816b5ed573a..9748763959300 100644 --- a/test/IRGen/builtin_vector.sil +++ b/test/IRGen/builtin_vector.sil @@ -5,7 +5,7 @@ import Builtin -// CHECK-LABEL: define{{( protected| dllexport)?}} swiftcc <4 x i32> @vector_int_add(<4 x i32>, <4 x i32>) {{.*}} { +// CHECK-LABEL: define{{( protected| dllexport)?}} swiftcc <4 x i32> @vector_int_add(<4 x i32> %0, <4 x i32> %1) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: %2 = add <4 x i32> %0, %1 // CHECK-NEXT: ret <4 x i32> %2 @@ -16,7 +16,7 @@ bb0(%0 : $Builtin.Vec4xInt32, %1 : $Builtin.Vec4xInt32): return %2 : $Builtin.Vec4xInt32 } -// CHECK-LABEL: define{{( protected| dllexport)?}} swiftcc <4 x float> @vector_float_add(<4 x float>, <4 x float>) {{.*}} { +// CHECK-LABEL: define{{( protected| dllexport)?}} swiftcc <4 x float> @vector_float_add(<4 x float> %0, <4 x float> %1) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: %2 = fadd <4 x float> %0, %1 // CHECK-NEXT: ret <4 x float> %2 diff --git a/test/IRGen/builtin_word.sil b/test/IRGen/builtin_word.sil index 516fe2244256e..6ab229da46c39 100644 --- a/test/IRGen/builtin_word.sil +++ b/test/IRGen/builtin_word.sil @@ -21,14 +21,14 @@ entry: return %w : $Builtin.Word } -// INTEL: define{{( protected)?}} swiftcc { i64, i64 } @word_zextOrBitCast(i32, i64) {{.*}} { +// INTEL: define{{( protected)?}} swiftcc { i64, i64 } @word_zextOrBitCast(i32 %0, i64 %1) {{.*}} { // INTEL: entry: // INTEL: %2 = zext i32 %0 to i64 // INTEL: %3 = insertvalue { i64, i64 } undef, i64 %2, 0 // INTEL: %4 = insertvalue { i64, i64 } %3, i64 %1, 1 // INTEL: ret { i64, i64 } %4 // INTEL: } -// ARM32: define{{( protected)?}} swiftcc { i32, i64 } @word_zextOrBitCast(i32, i32) {{.*}} { +// ARM32: define{{( protected)?}} swiftcc { i32, i64 } @word_zextOrBitCast(i32 %0, i32 %1) {{.*}} { // ARM32: entry: // ARM32: %2 = zext i32 %1 to i64 // ARM32: %3 = insertvalue { i32, i64 } undef, i32 %0, 0 @@ -43,14 +43,14 @@ entry(%i : $Builtin.Int32, %w : $Builtin.Word): return %t : $(Builtin.Word, Builtin.Int64) } -// INTEL: define{{( protected)?}} swiftcc { i32, i64 } @word_truncOrBitCast(i64, i64) {{.*}} { +// INTEL: define{{( protected)?}} swiftcc { i32, i64 } @word_truncOrBitCast(i64 %0, i64 %1) {{.*}} { // INTEL: entry: // INTEL: %2 = trunc i64 %0 to i32 // INTEL: %3 = insertvalue { i32, i64 } undef, i32 %2, 0 // INTEL: %4 = insertvalue { i32, i64 } %3, i64 %1, 1 // INTEL: ret { i32, i64 } %4 // INTEL: } -// ARM32: define{{( protected)?}} swiftcc { i32, i32 } @word_truncOrBitCast(i32, i64) {{.*}} { +// ARM32: define{{( protected)?}} swiftcc { i32, i32 } @word_truncOrBitCast(i32 %0, i64 %1) {{.*}} { // ARM32: entry: // ARM32: %2 = trunc i64 %1 to i32 // ARM32: %3 = insertvalue { i32, i32 } undef, i32 %0, 0 diff --git a/test/IRGen/builtins.swift b/test/IRGen/builtins.swift index 5688f02017928..d051f5ede450a 100644 --- a/test/IRGen/builtins.swift +++ b/test/IRGen/builtins.swift @@ -312,7 +312,7 @@ func testStaticReport(_ b: Bool, ptr: Builtin.RawPointer) -> () { return Builtin.staticReport(b, b, ptr); } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12testCondFail{{[_0-9a-zA-Z]*}}F"(i1, i1) +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12testCondFail{{[_0-9a-zA-Z]*}}F"(i1 %0, i1 %1) func testCondFail(_ b: Bool, c: Bool) { // CHECK: [[EXPECT:%.*]] = call i1 @llvm.expect.i1(i1 %0, i1 false) // CHECK: br i1 [[EXPECT]], label %[[FAIL:.*]], label %[[CONT:.*]] @@ -321,7 +321,7 @@ func testCondFail(_ b: Bool, c: Bool) { // CHECK: [[EXPECT:%.*]] = call i1 @llvm.expect.i1(i1 %1, i1 false) // CHECK: br i1 [[EXPECT]], label %[[FAIL2:.*]], label %[[CONT:.*]] Builtin.condfail_message(c, StaticString("message").unsafeRawPointer) - // CHECK: [[CONT]] + // CHECK: [[CONT]]: // CHECK: ret void // CHECK: [[FAIL]]: @@ -333,7 +333,7 @@ func testCondFail(_ b: Bool, c: Bool) { // CHECK: unreachable } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins8testOnce{{[_0-9a-zA-Z]*}}F"(i8*, i8*) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins8testOnce{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1) {{.*}} { // CHECK: [[PRED_PTR:%.*]] = bitcast i8* %0 to [[WORD:i64|i32]]* // CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]] // CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1 @@ -351,7 +351,7 @@ func testOnce(_ p: Builtin.RawPointer, f: @escaping @convention(c) () -> ()) { Builtin.once(p, f) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins19testOnceWithContext{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i8*) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins19testOnceWithContext{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1, i8* %2) {{.*}} { // CHECK: [[PRED_PTR:%.*]] = bitcast i8* %0 to [[WORD:i64|i32]]* // CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]] // CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1 @@ -405,21 +405,21 @@ func canBeClass(_ f: @escaping (Builtin.Int8) -> (), _: T) { f(Builtin.canBeClass(T.self)) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15destroyPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i64) +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15destroyPODArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i64 %1) // CHECK-NOT: loop: // CHECK: ret void func destroyPODArray(_ array: Builtin.RawPointer, count: Builtin.Word) { Builtin.destroyArray(Int.self, array, count) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins18destroyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i64) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins18destroyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i64 %1) {{.*}} { // CHECK-NOT: loop: // CHECK: call void @swift_arrayDestroy( func destroyNonPODArray(_ array: Builtin.RawPointer, count: Builtin.Word) { Builtin.destroyArray(C.self, array, count) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15destroyGenArray_5count_yBp_BwxtlF"(i8*, i64, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15destroyGenArray_5count_yBp_BwxtlF"(i8* %0, i64 %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) // CHECK-NOT: loop: // CHECK: call void @swift_arrayDestroy func destroyGenArray(_ array: Builtin.RawPointer, count: Builtin.Word, _: T) { @@ -427,7 +427,7 @@ func destroyGenArray(_ array: Builtin.RawPointer, count: Builtin.Word, _: T) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12copyPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64) +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12copyPODArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1, i64 %2) // check: mul nuw i64 4, %2 // check: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false) // check: mul nuw i64 4, %2 @@ -453,7 +453,7 @@ func copyPODArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Bu } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins11copyBTArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins11copyBTArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1, i64 %2) {{.*}} { // CHECK-NOT: loop: // CHECK: call void @swift_arrayInitWithCopy // CHECK: mul nuw i64 8, %2 @@ -476,7 +476,7 @@ func copyBTArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Bui struct W { weak var c: C? } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15copyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins15copyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1, i64 %2) {{.*}} { // CHECK-NOT: loop: // CHECK: call void @swift_arrayInitWithCopy( // CHECK-NOT: loop{{.*}}: @@ -497,7 +497,7 @@ func copyNonPODArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Builtin.assignTakeArray(W.self, dest, src, count) } -// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12copyGenArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define hidden {{.*}}void @"$s8builtins12copyGenArray{{[_0-9a-zA-Z]*}}F"(i8* %0, i8* %1, i64 %2, %swift.opaque* noalias nocapture %3, %swift.type* %T) // CHECK-NOT: loop: // CHECK: call void @swift_arrayInitWithCopy // CHECK-NOT: loop: @@ -593,11 +593,11 @@ func zeroInitializerEmpty() { // isUnique variants // ---------------------------------------------------------------------------- -// CHECK: define hidden {{.*}}void @"$s8builtins26acceptsBuiltinNativeObjectyyBoSgzF"([[BUILTIN_NATIVE_OBJECT_TY:%.*]]* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define hidden {{.*}}void @"$s8builtins26acceptsBuiltinNativeObjectyyBoSgzF"([[BUILTIN_NATIVE_OBJECT_TY:%.*]]* nocapture dereferenceable({{.*}}) %0) {{.*}} { func acceptsBuiltinNativeObject(_ ref: inout Builtin.NativeObject?) {} // native -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BoSgzF"({{%.*}}* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BoSgzF"({{%.*}}* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: bitcast [[BUILTIN_NATIVE_OBJECT_TY]]* %0 to %swift.refcounted** // CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1 @@ -608,7 +608,7 @@ func isUnique(_ ref: inout Builtin.NativeObject?) -> Bool { } // native nonNull -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %0 // CHECK-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %1) @@ -617,11 +617,11 @@ func isUnique(_ ref: inout Builtin.NativeObject) -> Bool { return Builtin.isUnique(&ref) } -// CHECK: define hidden {{.*}}void @"$s8builtins16acceptsAnyObjectyyyXlSgzF"([[OPTIONAL_ANYOBJECT_TY:%.*]]* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define hidden {{.*}}void @"$s8builtins16acceptsAnyObjectyyyXlSgzF"([[OPTIONAL_ANYOBJECT_TY:%.*]]* nocapture dereferenceable({{.*}}) %0) {{.*}} { func acceptsAnyObject(_ ref: inout Builtin.AnyObject?) {} // ObjC -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_yXlSgzF"({{%.*}}* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_yXlSgzF"({{%.*}}* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: [[ADDR:%.+]] = getelementptr inbounds [[OPTIONAL_ANYOBJECT_TY]], [[OPTIONAL_ANYOBJECT_TY]]* %0, i32 0, i32 0 // CHECK-NEXT: [[CASTED:%.+]] = bitcast {{.+}}* [[ADDR]] to [[UNKNOWN_OBJECT:%objc_object|%swift\.refcounted]]** @@ -635,7 +635,7 @@ func isUnique(_ ref: inout Builtin.AnyObject?) -> Bool { // ObjC nonNull // CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_yXlzF" -// CHECK-SAME: (%AnyObject* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-SAME: (%AnyObject* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: [[ADDR:%.+]] = getelementptr inbounds %AnyObject, %AnyObject* %0, i32 0, i32 0 // CHECK-NEXT: [[REF:%.+]] = load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** [[ADDR]] @@ -647,7 +647,7 @@ func isUnique(_ ref: inout Builtin.AnyObject) -> Bool { } // BridgeObject nonNull -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins8isUniqueyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: load %swift.bridge*, %swift.bridge** %0 // CHECK-NEXT: call i1 @swift_isUniquelyReferencedNonObjC_nonNull_bridgeObject(%swift.bridge* %1) @@ -663,7 +663,7 @@ func assumeTrue(_ x: Builtin.Int1) { Builtin.assume_Int1(x) } // BridgeObject nonNull -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins15isUnique_nativeyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins15isUnique_nativeyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: bitcast %swift.bridge** %0 to %swift.refcounted** // CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1 @@ -674,7 +674,7 @@ func isUnique_native(_ ref: inout Builtin.BridgeObject) -> Bool { } // ImplicitlyUnwrappedOptional argument to isUnique. -// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins11isUniqueIUOyBi1_BoSgzF"(%{{.*}}* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define hidden {{.*}}i1 @"$s8builtins11isUniqueIUOyBi1_BoSgzF"(%{{.*}}* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK: call i1 @swift_isUniquelyReferenced_native(%swift.refcounted* // CHECK: ret i1 @@ -787,7 +787,7 @@ func atomicload(_ p: Builtin.RawPointer) { Builtin.atomicstore_seqcst_volatile_FPIEEE32(p, d) } -// CHECK-LABEL: define {{.*}} @"$s8builtins14stringObjectOryS2u_SutF"(i64, i64) +// CHECK-LABEL: define {{.*}} @"$s8builtins14stringObjectOryS2u_SutF"(i64 %0, i64 %1) // CHECK: %4 = or i64 %0, %1 // CHECK-NEXT: ret i64 %4 func stringObjectOr(_ x: UInt, _ y: UInt) -> UInt { diff --git a/test/IRGen/c_function_pointer.sil b/test/IRGen/c_function_pointer.sil index e9f000674ebca..7b0f0c2fcd47e 100644 --- a/test/IRGen/c_function_pointer.sil +++ b/test/IRGen/c_function_pointer.sil @@ -2,13 +2,13 @@ import Swift -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} void @c_native_function_pointer(void ()*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} void @c_native_function_pointer(void ()* %0) sil @c_native_function_pointer : $@convention(c) (@convention(c) () -> ()) -> () { entry(%f : $@convention(c) () -> ()): return undef : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @call_with_native_c_function_pointer(i8*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @call_with_native_c_function_pointer(i8* %0) sil @call_with_native_c_function_pointer : $@convention(thin) (@convention(c) () -> ()) -> () { entry(%f : $@convention(c) () -> ()): %c = function_ref @c_native_function_pointer : $@convention(c) (@convention(c) () -> ()) -> () diff --git a/test/IRGen/c_layout.sil b/test/IRGen/c_layout.sil index a9489677ad898..9ada704fb897c 100644 --- a/test/IRGen/c_layout.sil +++ b/test/IRGen/c_layout.sil @@ -339,7 +339,7 @@ entry(%a : $CChar, %b : $CSignedChar, %c : $CUnsignedChar, %d : $CShort, %e : $C return undef : $() } -// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8 @testIntegerExtensionInBlock(%objc_block*, i8) +// CHECK-x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8 @testIntegerExtensionInBlock(%objc_block* %0, i8 %1) sil @testIntegerExtensionInBlock : $@convention(thin) (@owned @convention(block) (CChar) -> CChar, CChar) -> CChar { entry(%b : $@convention(block) (CChar) -> CChar, %c : $CChar): // CHECK-SYSV-x86_64: call signext i8 {{%.*}}(%objc_block* {{%.*}}, i8 signext {{%.*}}) diff --git a/test/IRGen/casts.sil b/test/IRGen/casts.sil index 2d27987f213a2..6a3cc629629b3 100644 --- a/test/IRGen/casts.sil +++ b/test/IRGen/casts.sil @@ -15,7 +15,7 @@ class B: A {} sil_vtable A {} sil_vtable B {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1BC* @unchecked_addr_cast(%T5casts1AC** noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1BC* @unchecked_addr_cast(%T5casts1AC** noalias nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: bitcast %T5casts1AC** %0 to %T5casts1BC** sil @unchecked_addr_cast : $(@in A) -> B { entry(%a : $*A): @@ -28,7 +28,7 @@ protocol CP: class {} protocol CP2: class {} @objc protocol OP: class {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @ref_to_raw_pointer_existential(%objc_object*, i8**) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @ref_to_raw_pointer_existential(%objc_object* %0, i8** %1) {{.*}} { // CHECK: [[CAST:%.*]] = bitcast %objc_object* %0 to i8* // CHECK: ret i8* [[CAST]] sil @ref_to_raw_pointer_existential : $@convention(thin) (@owned CP) -> Builtin.RawPointer { @@ -37,7 +37,7 @@ entry(%p : $CP): return %r : $Builtin.RawPointer } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @raw_pointer_to_ref_existential(i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @raw_pointer_to_ref_existential(i8* %0) {{.*}} { // CHECK: [[CAST:%.*]] = bitcast i8* %0 to %objc_object* // CHECK: ret %objc_object* [[CAST]] sil @raw_pointer_to_ref_existential : $@convention(thin) (@owned Builtin.RawPointer) -> AnyObject { @@ -52,9 +52,9 @@ entry(%n : $Builtin.NativeObject): return %r : $AnyObject } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8** } @u_cast_to_class_existential(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8** } @u_cast_to_class_existential(%objc_object* %0) // CHECK: call { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8* {{%.*}}, %swift.type* {{%.*}}, {{.*}} @"$s5casts2CPMp" -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8*, %swift.type*, %swift.protocol*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8* %0, %swift.type* %1, %swift.protocol* %2) {{.*}} { // CHECK: [[WITNESS:%.*]] = call i8** @swift_conformsToProtocol(%swift.type* %1, %swift.protocol* %2) // CHECK: [[IS_NULL:%.*]] = icmp eq i8** [[WITNESS]], null // CHECK: br i1 [[IS_NULL]], label %fail, label %cont @@ -70,7 +70,7 @@ entry(%a : $AnyObject): return %p : $CP } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8** } @u_cast_to_existential_metatype(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8** } @u_cast_to_existential_metatype(%swift.type* %0) // CHECK: call { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8* %1, %swift.type* %0, {{.*}} @"$s5casts2CPMp" sil @u_cast_to_existential_metatype : $@convention(thin) (@owned @thick Any.Type) -> @owned @thick CP.Type { entry(%a : $@thick Any.Type): @@ -78,9 +78,9 @@ entry(%a : $@thick Any.Type): return %p : $@thick CP.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @u_cast_to_class_existential_2(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @u_cast_to_class_existential_2(%objc_object* %0) // CHECK: call { i8*, i8**, i8** } @dynamic_cast_existential_2_unconditional(i8* {{%.*}}, %swift.type* {{%.*}}, {{.*}} @"$s5casts2CPMp"{{[^,]*}}, {{.*}} @"$s5casts3CP2Mp" -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8**, i8** } @dynamic_cast_existential_2_unconditional(i8*, %swift.type*, %swift.protocol*, %swift.protocol*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8**, i8** } @dynamic_cast_existential_2_unconditional(i8* %0, %swift.type* %1, %swift.protocol* %2, %swift.protocol* %3) // CHECK: [[WITNESS:%.*]] = call i8** @swift_conformsToProtocol(%swift.type* %1, %swift.protocol* %2) // CHECK: [[IS_NULL:%.*]] = icmp eq i8** [[WITNESS]], null // CHECK: br i1 [[IS_NULL]], label %fail, label %cont @@ -98,7 +98,7 @@ entry(%a : $AnyObject): return %p : $CP & CP2 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @u_cast_to_class_existential_mixed(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @u_cast_to_class_existential_mixed(%objc_object* %0) // CHECK: call %objc_object* @swift_dynamicCastObjCProtocolUnconditional // CHECK: call { i8*, i8**, i8** } @dynamic_cast_existential_2_unconditional(i8* {{%.*}}, %swift.type* {{%.*}}, {{.*}} @"$s5casts2CPMp" {{[^,]*}}, {{.*}} @"$s5casts3CP2Mp" sil @u_cast_to_class_existential_mixed : $@convention(thin) (@owned AnyObject) -> @owned CP & OP & CP2 { @@ -107,7 +107,7 @@ entry(%a : $AnyObject): return %p : $CP & OP & CP2 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8**, i8** } @u_cast_to_existential_metatype_mixed(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8**, i8** } @u_cast_to_existential_metatype_mixed(%swift.type* %0) // CHECK: call %swift.type* @swift_dynamicCastTypeToObjCProtocolUnconditional(%swift.type* %0, {{(i32|i64)}} 1, i8** {{%.*}}) // CHECK: [[CAST:%.*]] = call { i8*, i8**, i8** } @dynamic_cast_existential_2_unconditional(i8* {{.*}}, %swift.type* %0, {{.*}} @"$s5casts2CPMp" {{[^,]*}}, {{.*}} @"$s5casts3CP2Mp" // CHECK: [[OBJPTR:%.*]] = extractvalue { i8*, i8**, i8** } [[CAST]], 0 @@ -120,9 +120,9 @@ entry(%a : $@thick Any.Type): } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8** } @c_cast_to_class_existential(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8** } @c_cast_to_class_existential(%objc_object* %0) // CHECK: call { i8*, i8** } @dynamic_cast_existential_1_conditional(i8* {{.*}}, %swift.type* %.Type, {{.*}} @"$s5casts2CPMp" -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8** } @dynamic_cast_existential_1_conditional(i8*, %swift.type*, %swift.protocol*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8** } @dynamic_cast_existential_1_conditional(i8* %0, %swift.type* %1, %swift.protocol* %2) // CHECK: [[WITNESS:%.*]] = call i8** @swift_conformsToProtocol(%swift.type* %1, %swift.protocol* %2) // CHECK: [[IS_NULL:%.*]] = icmp eq i8** [[WITNESS]], null // CHECK: br i1 [[IS_NULL]], label %fail, label %cont @@ -139,7 +139,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8** } @c_cast_to_existential_metatype(%swift.type*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8** } @c_cast_to_existential_metatype(%swift.type* %0) {{.*}} { // CHECK: call { i8*, i8** } @dynamic_cast_existential_1_conditional(i8* %1, %swift.type* %0, {{.*}} @"$s5casts2CPMp" sil @c_cast_to_existential_metatype : $@convention(thin) (@owned @thick Any.Type) -> @owned @thick CP.Type { entry(%a : $@thick Any.Type): @@ -150,9 +150,9 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @c_cast_to_class_existential_2(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @c_cast_to_class_existential_2(%objc_object* %0) // CHECK: call { i8*, i8**, i8** } @dynamic_cast_existential_2_conditional(i8* {{%.*}}, %swift.type* {{%.*}}, {{.*}} @"$s5casts2CPMp" {{[^,]*}}, {{.*}} @"$s5casts3CP2Mp" -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8**, i8** } @dynamic_cast_existential_2_conditional(i8*, %swift.type*, %swift.protocol*, %swift.protocol*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} private { i8*, i8**, i8** } @dynamic_cast_existential_2_conditional(i8* %0, %swift.type* %1, %swift.protocol* %2, %swift.protocol* %3) // CHECK: [[WITNESS:%.*]] = call i8** @swift_conformsToProtocol(%swift.type* %1, %swift.protocol* %2) // CHECK: [[IS_NULL:%.*]] = icmp eq i8** [[WITNESS]], null // CHECK: br i1 [[IS_NULL]], label %fail, label %cont @@ -173,7 +173,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @c_cast_to_class_existential_mixed(%objc_object*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %objc_object*, i8**, i8** } @c_cast_to_class_existential_mixed(%objc_object* %0) // CHECK: [[CAST:%.*]] = call %objc_object* @swift_dynamicCastObjCProtocolConditional // CHECK: [[IS_NULL:%.*]] = icmp eq %objc_object* [[CAST]], null // CHECK: br i1 [[IS_NULL]], label %cont, label %success @@ -191,7 +191,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8**, i8** } @c_cast_to_existential_metatype_mixed(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.type*, i8**, i8** } @c_cast_to_existential_metatype_mixed(%swift.type* %0) // CHECK: [[OBJC_CAST:%.*]] = call %swift.type* @swift_dynamicCastTypeToObjCProtocolConditional(%swift.type* %0, {{(i32|i64)}} 1, i8** {{%.*}}) // CHECK: [[IS_NULL:%.*]] = icmp eq %swift.type* [[OBJC_CAST]], null // CHECK: br i1 [[IS_NULL]], label %cont, label %success @@ -206,7 +206,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @checked_upcast(%T5casts1AC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @checked_upcast(%T5casts1AC* %0) {{.*}} { // -- Don't need to check conformance of an object to AnyObject. // CHECK-NOT: call %objc_object* @swift_dynamicCastObjCProtocolConditional // CHECK: phi %objc_object* @@ -219,7 +219,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1AC* @checked_downcast_optional({{(i32|i64)}}) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1AC* @checked_downcast_optional({{(i32|i64)}} %0) {{.*}} { // CHECK: [[T0:%.*]] = inttoptr {{(i32|i64)}} %0 to %T5casts1AC* // CHECK: [[OBJ_PTR:%.*]] = bitcast %T5casts1AC* [[T0]] to i8* // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s5casts1ACMa"([[INT]] 0) @@ -238,7 +238,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @checked_downcast_optional_metatype({{(i32|i64)}}) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @checked_downcast_optional_metatype({{(i32|i64)}} %0) {{.*}} { // CHECK: [[VALUE:%.*]] = inttoptr {{(i32|i64)}} %0 to %swift.type* // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s5casts1BCMa"([[INT]] 0) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 @@ -254,7 +254,7 @@ nay: unreachable } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @checked_downcast_optional_exmetatype({{(i32, i32|i64, i64)}}) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @checked_downcast_optional_exmetatype({{(i32 %0, i32 %1|i64 %0, i64 %1)}}) {{.*}} { // CHECK: [[VALUE:%.*]] = inttoptr {{(i32|i64)}} %0 to %swift.type* // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s5casts1BCMa"([[INT]] 0) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 @@ -270,7 +270,7 @@ nay: unreachable } -// CHECK: define {{(dllexport )?}}{{(protected )?}}swiftcc {{.*}} @checked_downcast_optional_class_to_ex([[INT]]) +// CHECK: define {{(dllexport )?}}{{(protected )?}}swiftcc {{.*}} @checked_downcast_optional_class_to_ex([[INT]] %0) // CHECK: entry: // CHECK: [[V1:%.*]] = inttoptr [[INT]] %0 to %T5casts1AC* // CHECK: [[V2:%.*]] = icmp ne %T5casts1AC* [[V1]], null @@ -344,7 +344,7 @@ entry(%x : $OB): return %x : $OB } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1BC* @checked_object_to_object_casts(%T5casts1AC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts1BC* @checked_object_to_object_casts(%T5casts1AC* %0) // CHECK: @swift_dynamicCastClassUnconditional sil @checked_object_to_object_casts : $@convention(thin) (A) -> B { entry(%a : $A): @@ -352,7 +352,7 @@ entry(%a : $A): return %b : $B } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts2OBC* @checked_objc_object_to_object_casts(%T5casts2OAC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5casts2OBC* @checked_objc_object_to_object_casts(%T5casts2OAC* %0) // CHECK: @swift_dynamicCastClassUnconditional sil @checked_objc_object_to_object_casts : $@convention(thin) (OA) -> OB { entry(%a : $OA): diff --git a/test/IRGen/cf.sil b/test/IRGen/cf.sil index 6d758f7a01c40..1e5d2e4acf133 100644 --- a/test/IRGen/cf.sil +++ b/test/IRGen/cf.sil @@ -50,7 +50,7 @@ bb0(%0 : $CCRefrigerator, %1: $CCMutableRefrigerator): } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @call_generic -// CHECK-SAME: ([[REFRIGERATOR]]*, [[MUTABLE_REFRIGERATOR]]*) {{.*}} { +// CHECK-SAME: ([[REFRIGERATOR]]* %0, [[MUTABLE_REFRIGERATOR]]* %1) {{.*}} { // CHECK: [[T0:%.*]] = bitcast [[REFRIGERATOR]]* %0 to [[OBJC]]* // CHECK-NEXT: [[T1:%.*]] = call swiftcc %swift.metadata_response @"$sSo17CCRefrigeratorRefaMa"([[INT]] 0) // CHECK-NEXT: [[T2:%.*]] = extractvalue %swift.metadata_response [[T1]], 0 @@ -65,7 +65,7 @@ bb0(%0 : $CCRefrigerator, %1: $CCMutableRefrigerator): // CHECK: call swiftcc %swift.metadata_response @swift_getForeignTypeMetadata([[INT]] %0, // CHECK-SAME: @"$sSo17CCRefrigeratorRefaMf" -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$sSo24CCMutableRefrigeratorRefaMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$sSo24CCMutableRefrigeratorRefaMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$sSo17CCRefrigeratorRefaMa"([[INT]] 255) // CHECK-NEXT: [[T1:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-NEXT: extractvalue %swift.metadata_response [[T0]], 1 diff --git a/test/IRGen/clang_inline.swift b/test/IRGen/clang_inline.swift index 561de9bce35ab..bb1fbba8061c2 100644 --- a/test/IRGen/clang_inline.swift +++ b/test/IRGen/clang_inline.swift @@ -15,7 +15,7 @@ import gizmo -// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF"(%T12clang_inline16CallStaticInlineC* swiftself) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF"(%T12clang_inline16CallStaticInlineC* swiftself %0) {{.*}} { class CallStaticInline { func ReturnZero() -> Int64 { return Int64(zero()) } } @@ -23,7 +23,7 @@ class CallStaticInline { // CHECK-LABEL: define internal i32 @zero() // CHECK-SAME: [[INLINEHINT_SSP_UWTABLE:#[0-9]+]] { -// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF"(%T12clang_inline17CallStaticInline2C* swiftself) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF"(%T12clang_inline17CallStaticInline2C* swiftself %0) {{.*}} { class CallStaticInline2 { func ReturnZero() -> Int64 { return Int64(wrappedZero()) } } diff --git a/test/IRGen/clang_inline_reverse.swift b/test/IRGen/clang_inline_reverse.swift index 4397fdf62bccb..d816c8ae3d860 100644 --- a/test/IRGen/clang_inline_reverse.swift +++ b/test/IRGen/clang_inline_reverse.swift @@ -9,14 +9,14 @@ import gizmo -// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF"(%T12clang_inline16CallStaticInlineC* swiftself) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline16CallStaticInlineC10ReturnZeros5Int64VyF"(%T12clang_inline16CallStaticInlineC* swiftself %0) {{.*}} { class CallStaticInline { func ReturnZero() -> Int64 { return Int64(wrappedZero()) } } // CHECK-LABEL: define internal i32 @wrappedZero() {{#[0-9]+}} { -// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF"(%T12clang_inline17CallStaticInline2C* swiftself) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i64 @"$s12clang_inline17CallStaticInline2C10ReturnZeros5Int64VyF"(%T12clang_inline17CallStaticInline2C* swiftself %0) {{.*}} { class CallStaticInline2 { func ReturnZero() -> Int64 { return Int64(zero()) } } diff --git a/test/IRGen/class.sil b/test/IRGen/class.sil index 3691670723364..4162d5ece885c 100644 --- a/test/IRGen/class.sil +++ b/test/IRGen/class.sil @@ -45,7 +45,7 @@ sil_vtable C {} // CHECK-SAME: }> // Destroying destructor -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[REF]]* @"$s5class1CCfd"([[C_CLASS]]* swiftself) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[REF]]* @"$s5class1CCfd"([[C_CLASS]]* swiftself %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: [[OBJ_PTR:%[a-zA-Z0-9]+]] = bitcast [[C_CLASS]]* %0 to [[REF]]* // CHECK-NEXT: ret [[REF]]* [[OBJ_PTR]] @@ -56,7 +56,7 @@ bb0(%0 : $C): } // Deallocating destructor -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5class1CCfD"([[C_CLASS]]* swiftself) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5class1CCfD"([[C_CLASS]]* swiftself %0) sil @$s5class1CCfD : $@convention(method) (@owned C) -> () { bb0(%0 : $C): // CHECK-NEXT: entry @@ -73,7 +73,7 @@ bb0(%0 : $C): return %5 : $() // id: %6 } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[REF]]* @unchecked_ref_cast_cast([[C_CLASS]]*) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[REF]]* @unchecked_ref_cast_cast([[C_CLASS]]* %0) // CHECK: bitcast [[C_CLASS]]* {{%.*}} to [[REF]]* sil @unchecked_ref_cast_cast : $@convention(thin) (C) -> Builtin.NativeObject { entry(%c : $C): @@ -81,7 +81,7 @@ entry(%c : $C): return %r : $Builtin.NativeObject } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[OBJCOBJ]]* @ref_to_objc_pointer_cast([[C_CLASS]]*) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc [[OBJCOBJ]]* @ref_to_objc_pointer_cast([[C_CLASS]]* %0) // CHECK: bitcast [[C_CLASS]]* %0 to [[OBJCOBJ]]* sil @ref_to_objc_pointer_cast : $@convention(thin) (C) -> Builtin.AnyObject { entry(%c : $C): @@ -89,7 +89,7 @@ entry(%c : $C): return %r : $Builtin.AnyObject } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class1CC* @alloc_ref_dynamic(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class1CC* @alloc_ref_dynamic(%swift.type* %0) sil @alloc_ref_dynamic : $@convention(thin) (@thick C.Type) -> @owned C { bb0(%0 : $@thick C.Type): // CHECK: [[META_PTR:%[0-9]+]] = bitcast %swift.type* %0 to i8* @@ -106,7 +106,7 @@ bb0(%0 : $@thick C.Type): return %1 : $C } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class1CC* @autorelease(%T5class1CC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class1CC* @autorelease(%T5class1CC* %0) {{.*}} { // CHECK: %1 = bitcast %T5class1CC* %0 to i8* // CHECK: call i8* @llvm.objc.autorelease(i8* %1) // CHECK: ret %T5class1CC* %0 @@ -116,7 +116,7 @@ entry(%c : $C): return %c : $C } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @autorelease_optional(i64) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @autorelease_optional(i64 %0) {{.*}} { // CHECK: %1 = inttoptr i64 %0 to i8* // CHECK: call i8* @llvm.objc.autorelease(i8* %1) // CHECK: ret i64 %0 @@ -164,7 +164,7 @@ entry(%x : $ClassConstrainedGenericField): %b = load %a : $*ClassConstraintConformance return %b : $ClassConstraintConformance } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class26ClassConstraintConformanceC* @fixed_class_generic_field(%T5class28ClassConstrainedGenericFieldCyAA0B21ConstraintConformanceCG*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T5class26ClassConstraintConformanceC* @fixed_class_generic_field(%T5class28ClassConstrainedGenericFieldCyAA0B21ConstraintConformanceCG* %0) // CHECK: [[FIELD_ADDR_GENERIC:%.*]] = getelementptr inbounds %T5class28ClassConstrainedGenericFieldCyAA0B21ConstraintConformanceCG, %T5class28ClassConstrainedGenericFieldCyAA0B21ConstraintConformanceCG* %0, i32 0, i32 1 // CHECK: load %T5class26ClassConstraintConformanceC*, %T5class26ClassConstraintConformanceC** [[FIELD_ADDR_GENERIC]] diff --git a/test/IRGen/class_bounded_generics.swift b/test/IRGen/class_bounded_generics.swift index a3ae39429c697..7f4bfa4959633 100644 --- a/test/IRGen/class_bounded_generics.swift +++ b/test/IRGen/class_bounded_generics.swift @@ -58,7 +58,7 @@ class ClassProtocolFieldClass { // CHECK-DAG: %T22class_bounded_generics23ClassGenericFieldStructV = type <{ %TSi, %objc_object*, %TSi }> // CHECK-DAG: %T22class_bounded_generics24ClassProtocolFieldStructV = type <{ %TSi, %T22class_bounded_generics10ClassBoundP, %TSi }> -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics0a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound) +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics0a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T, i8** %T.ClassBound) func class_bounded_archetype(_ x: T) -> T { return x } @@ -66,12 +66,12 @@ func class_bounded_archetype(_ x: T) -> T { class SomeClass {} class SomeSubclass : SomeClass {} -// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics9SomeClassC* @"$s22class_bounded_generics011superclass_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics9SomeClassC* @"$s22class_bounded_generics011superclass_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC* %0, %swift.type* %T) func superclass_bounded_archetype(_ x: T) -> T { return x } -// CHECK-LABEL: define hidden swiftcc { %T22class_bounded_generics9SomeClassC*, %T22class_bounded_generics12SomeSubclassC* } @"$s22class_bounded_generics011superclass_B15_archetype_call{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC*, %T22class_bounded_generics12SomeSubclassC*) +// CHECK-LABEL: define hidden swiftcc { %T22class_bounded_generics9SomeClassC*, %T22class_bounded_generics12SomeSubclassC* } @"$s22class_bounded_generics011superclass_B15_archetype_call{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC* %0, %T22class_bounded_generics12SomeSubclassC* %1) func superclass_bounded_archetype_call(_ x: SomeClass, y: SomeSubclass) -> (SomeClass, SomeSubclass) { return (superclass_bounded_archetype(x), superclass_bounded_archetype(y)); @@ -81,7 +81,7 @@ func superclass_bounded_archetype_call(_ x: SomeClass, y: SomeSubclass) -> (Some // CHECK: bitcast %T22class_bounded_generics9SomeClassC* [[SOMESUPERCLASS_RESULT]] to %T22class_bounded_generics12SomeSubclassC* } -// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics0a1_B17_archetype_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, %objc_object*, %swift.type* %T, i8** %T.ClassBoundBinary) +// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics0a1_B17_archetype_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %objc_object* %1, %swift.type* %T, i8** %T.ClassBoundBinary) func class_bounded_archetype_method(_ x: T, y: T) { x.classBoundMethod() // CHECK: [[INHERITED_GEP:%.*]] = getelementptr inbounds i8*, i8** %T.ClassBoundBinary, i32 1 @@ -99,7 +99,7 @@ func class_bounded_archetype_method(_ x: T, y: T) { // CHECK: call swiftcc void [[WITNESS_FUNC]](%objc_object* %1, %objc_object* swiftself %0, %swift.type* %T, i8** %T.ClassBoundBinary) } -// CHECK-LABEL: define hidden swiftcc { %objc_object*, %objc_object* } @"$s22class_bounded_generics0a1_B16_archetype_tuple{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound) +// CHECK-LABEL: define hidden swiftcc { %objc_object*, %objc_object* } @"$s22class_bounded_generics0a1_B16_archetype_tuple{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T, i8** %T.ClassBound) func class_bounded_archetype_tuple(_ x: T) -> (T, T) { return (x, x) } @@ -111,7 +111,7 @@ class ConcreteClass : ClassBoundBinary, NotClassBound { func notClassBoundBinaryMethod(_ x: ConcreteClass) {} } -// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics05call_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics05call_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC* %0) {{.*}} { func call_class_bounded_archetype(_ x: ConcreteClass) -> ConcreteClass { return class_bounded_archetype(x) // CHECK: [[IN:%.*]] = bitcast %T22class_bounded_generics13ConcreteClassC* {{%.*}} to %objc_object* @@ -120,12 +120,12 @@ func call_class_bounded_archetype(_ x: ConcreteClass) -> ConcreteClass { // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]] } -// CHECK: define hidden swiftcc void @"$s22class_bounded_generics04not_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.NotClassBound) +// CHECK: define hidden swiftcc void @"$s22class_bounded_generics04not_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, i8** %T.NotClassBound) func not_class_bounded_archetype(_ x: T) -> T { return x } -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics0a1_b18_archetype_to_not_a1_B0{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound, i8** %T.NotClassBound) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics0a1_b18_archetype_to_not_a1_B0{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T, i8** %T.ClassBound, i8** %T.NotClassBound) {{.*}} { func class_bounded_archetype_to_not_class_bounded (_ x:T) -> T { // CHECK: alloca %objc_object*, align 8 @@ -142,7 +142,7 @@ func class_and_not_class_bounded_archetype_methods } */ -// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B8_erasure{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B8_erasure{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC* %0) {{.*}} { func class_bounded_erasure(_ x: ConcreteClass) -> ClassBound { return x // CHECK: [[INSTANCE_OPAQUE:%.*]] = bitcast %T22class_bounded_generics13ConcreteClassC* [[INSTANCE:%.*]] to %objc_object* @@ -151,7 +151,7 @@ func class_bounded_erasure(_ x: ConcreteClass) -> ClassBound { // CHECK: ret { %objc_object*, i8** } [[T1]] } -// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics0a1_B16_protocol_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, i8**) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics0a1_B16_protocol_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, i8** %1) {{.*}} { func class_bounded_protocol_method(_ x: ClassBound) { x.classBoundMethod() // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getObjectType(%objc_object* %0) @@ -161,7 +161,7 @@ func class_bounded_protocol_method(_ x: ClassBound) { // CHECK: call swiftcc void [[WITNESS_FN]](%objc_object* swiftself %0, %swift.type* [[METADATA]], i8** [[WITNESS_TABLE]]) } -// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics0a1_B15_archetype_cast{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound) +// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics0a1_B15_archetype_cast{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T, i8** %T.ClassBound) func class_bounded_archetype_cast(_ x: T) -> ConcreteClass { return x as! ConcreteClass // CHECK: [[IN_PTR:%.*]] = bitcast %objc_object* {{%.*}} to i8* @@ -173,7 +173,7 @@ func class_bounded_archetype_cast(_ x: T) -> ConcreteClass { // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]] } -// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics0a1_B14_protocol_cast{{[_0-9a-zA-Z]*}}F"(%objc_object*, i8**) +// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$s22class_bounded_generics0a1_B14_protocol_cast{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, i8** %1) func class_bounded_protocol_cast(_ x: ClassBound) -> ConcreteClass { return x as! ConcreteClass // CHECK: [[IN_PTR:%.*]] = bitcast %objc_object* {{%.*}} to i8* @@ -185,51 +185,51 @@ func class_bounded_protocol_cast(_ x: ClassBound) -> ConcreteClass { // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]] } -// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**, i8**) {{.*}} { +// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0, i8** %1, i8** %2) {{.*}} { func class_bounded_protocol_conversion_1(_ x: ClassBound & ClassBound2) -> ClassBound { return x } -// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**, i8**) {{.*}} { +// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0, i8** %1, i8** %2) {{.*}} { func class_bounded_protocol_conversion_2(_ x: ClassBound & ClassBound2) -> ClassBound2 { return x } -// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**) {{.*}} { +// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0, i8** %1) {{.*}} { func objc_class_bounded_protocol_conversion_1 (_ x: ClassBound & ObjCClassBound) -> ClassBound { return x } -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0, i8** %1) {{.*}} { func objc_class_bounded_protocol_conversion_2 (_ x: ClassBound & ObjCClassBound) -> ObjCClassBound { return x } -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*) +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0) func objc_class_bounded_protocol_conversion_3 (_ x: ObjCClassBound & ObjCClassBound2) -> ObjCClassBound { return x } -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*) +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object* %0) func objc_class_bounded_protocol_conversion_4 (_ x: ObjCClassBound & ObjCClassBound2) -> ObjCClassBound2 { return x } -// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$s22class_bounded_generics0A28_generic_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64, %objc_object*, i64, %swift.type* %T, i8** %T.ClassBound) +// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$s22class_bounded_generics0A28_generic_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64 %0, %objc_object* %1, i64 %2, %swift.type* %T, i8** %T.ClassBound) func class_generic_field_struct_fields (_ x:ClassGenericFieldStruct) -> (Int, T, Int) { return (x.x, x.y, x.z) } -// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$s22class_bounded_generics0A29_protocol_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64, %objc_object*, i8**, i64) +// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$s22class_bounded_generics0A29_protocol_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64 %0, %objc_object* %1, i8** %2, i64 %3) func class_protocol_field_struct_fields (_ x:ClassProtocolFieldStruct) -> (Int, ClassBound, Int) { return (x.x, x.y, x.z) } -// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$s22class_bounded_generics0a15_generic_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics017ClassGenericFieldD0C*) +// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$s22class_bounded_generics0a15_generic_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics017ClassGenericFieldD0C* %0) func class_generic_field_class_fields (_ x:ClassGenericFieldClass) -> (Int, T, Int) { return (x.x, x.y, x.z) @@ -238,7 +238,7 @@ func class_generic_field_class_fields // CHECK: getelementptr inbounds %T22class_bounded_generics017ClassGenericFieldD0C, %T22class_bounded_generics017ClassGenericFieldD0C* %0, i32 0, i32 3 } -// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$s22class_bounded_generics0a16_protocol_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics018ClassProtocolFieldD0C*) +// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$s22class_bounded_generics0a16_protocol_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics018ClassProtocolFieldD0C* %0) func class_protocol_field_class_fields(_ x: ClassProtocolFieldClass) -> (Int, ClassBound, Int) { return (x.x, x.y, x.z) @@ -278,10 +278,10 @@ class M> { } } -// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type* %0, %swift.type* %T) func takes_metatype(_: T.Type) {} -// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics023archetype_with_generic_A11_constraint1tyx_tAA1ACyq_GRbzr0_lF"(%T22class_bounded_generics1AC.1*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics023archetype_with_generic_A11_constraint1tyx_tAA1ACyq_GRbzr0_lF"(%T22class_bounded_generics1AC.1* %0, %swift.type* %T) // CHECK: [[ISA_ADDR:%.*]] = bitcast %T22class_bounded_generics1AC.1* %0 to %swift.type** // CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_ADDR]] // CHECK: call swiftcc void @"$s22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type* %T, %swift.type* %T) @@ -296,7 +296,7 @@ func archetype_with_generic_class_constraint(t: T) where T : A { takes_metatype(U.self) } -// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics029calls_archetype_with_generic_A11_constraint1ayAA1ACyxG_tlF"(%T22class_bounded_generics1AC*) #0 { +// CHECK-LABEL: define hidden swiftcc void @"$s22class_bounded_generics029calls_archetype_with_generic_A11_constraint1ayAA1ACyxG_tlF"(%T22class_bounded_generics1AC* %0) {{.*}} { // CHECK: alloca // CHECK: memset // CHECK: [[ISA_ADDR:%.*]] = getelementptr inbounds %T22class_bounded_generics1AC, %T22class_bounded_generics1AC* %0, i32 0, i32 0, i32 0 diff --git a/test/IRGen/class_constraint.sil b/test/IRGen/class_constraint.sil index 2d13746e8895f..d404d8e204cca 100644 --- a/test/IRGen/class_constraint.sil +++ b/test/IRGen/class_constraint.sil @@ -22,5 +22,5 @@ bb0(%0 : $T): %3 = tuple () return %3 : $() } -// CHECK: define {{.*}}void @foo(%T16class_constraint1AC*, %swift.type* %T) +// CHECK: define {{.*}}void @foo(%T16class_constraint1AC* %0, %swift.type* %T) // CHECK: store i8** @"$s16class_constraint1ACAA1PAAWP", diff --git a/test/IRGen/class_field_other_module.swift b/test/IRGen/class_field_other_module.swift index 8c2f037a8eea9..75f8578c345c5 100644 --- a/test/IRGen/class_field_other_module.swift +++ b/test/IRGen/class_field_other_module.swift @@ -5,7 +5,7 @@ import other_class -// CHECK-LABEL: define {{(protected )?}}{{(dllexport )?}}swiftcc i32 @"$s24class_field_other_module12getSubclassXys5Int32V0c1_A00F0CF"(%T11other_class8SubclassC* nocapture readonly) +// CHECK-LABEL: define {{(protected )?}}{{(dllexport )?}}swiftcc i32 @"$s24class_field_other_module12getSubclassXys5Int32V0c1_A00F0CF"(%T11other_class8SubclassC* nocapture readonly %0) // CHECK-NEXT: entry: // CHECK-NEXT: %._value = getelementptr inbounds %T11other_class8SubclassC, %T11other_class8SubclassC* %0, [[INT]] 0, i32 1, i32 0 // CHECK-NEXT: %1 = load i32, i32* %._value @@ -14,7 +14,7 @@ public func getSubclassX(_ o: Subclass) -> Int32 { return o.x } -// CHECK-LABEL: define {{(protected )?}}{{(dllexport )?}}swiftcc i32 @"$s24class_field_other_module12getSubclassYys5Int32V0c1_A00F0CF"(%T11other_class8SubclassC* nocapture readonly) +// CHECK-LABEL: define {{(protected )?}}{{(dllexport )?}}swiftcc i32 @"$s24class_field_other_module12getSubclassYys5Int32V0c1_A00F0CF"(%T11other_class8SubclassC* nocapture readonly %0) // CHECK-NEXT: entry: // CHECK-NEXT: %._value = getelementptr inbounds %T11other_class8SubclassC, %T11other_class8SubclassC* %0, [[INT]] 0, i32 2, i32 0 // CHECK-NEXT: %1 = load i32, i32* %._value diff --git a/test/IRGen/class_isa_pointers.sil b/test/IRGen/class_isa_pointers.sil index cd4c364dee924..f4ec02eea1090 100644 --- a/test/IRGen/class_isa_pointers.sil +++ b/test/IRGen/class_isa_pointers.sil @@ -17,7 +17,7 @@ class Purebred { } sil_vtable Purebred {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @purebred_method(%T18class_isa_pointers8PurebredC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @purebred_method(%T18class_isa_pointers8PurebredC* %0) {{.*}} { // CHECK: [[ISA_PTR:%.*]] = bitcast %T18class_isa_pointers8PurebredC* %0 to %swift.type** // CHECK: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_PTR]] // CHECK: [[VTABLE:%.*]] = bitcast %swift.type* [[ISA]] @@ -38,7 +38,7 @@ class Mongrel: Gizmo { } sil_vtable Mongrel {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @mongrel_method(%T18class_isa_pointers7MongrelC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @mongrel_method(%T18class_isa_pointers7MongrelC* %0) {{.*}} { // CHECK: [[T0:%.*]] = bitcast {{.*}} %0 to i64* // CHECK-NEXT: [[T1:%.*]] = load i64, i64* [[T0]], align 8 // CHECK-NEXT: [[T2:%.*]] = load i64, i64* @swift_isaMask, align 8 diff --git a/test/IRGen/class_resilience.swift b/test/IRGen/class_resilience.swift index 1c8960c2bb9ee..662a785409c84 100644 --- a/test/IRGen/class_resilience.swift +++ b/test/IRGen/class_resilience.swift @@ -280,7 +280,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientProperty.color getter -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience26ClassWithResilientPropertyC5colors5Int32Vvg"(%T16class_resilience26ClassWithResilientPropertyC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience26ClassWithResilientPropertyC5colors5Int32Vvg"(%T16class_resilience26ClassWithResilientPropertyC* swiftself %0) // CHECK: [[OFFSET:%.*]] = load [[INT]], [[INT]]* @"$s16class_resilience26ClassWithResilientPropertyC5colors5Int32VvpWvd" // CHECK-NEXT: [[PTR:%.*]] = bitcast %T16class_resilience26ClassWithResilientPropertyC* %0 to i8* // CHECK-NEXT: [[FIELD_ADDR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], [[INT]] [[OFFSET]] @@ -291,7 +291,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientlySizedProperty.color getter -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience33ClassWithResilientlySizedPropertyC5colors5Int32Vvg"(%T16class_resilience33ClassWithResilientlySizedPropertyC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience33ClassWithResilientlySizedPropertyC5colors5Int32Vvg"(%T16class_resilience33ClassWithResilientlySizedPropertyC* swiftself %0) // CHECK: [[OFFSET:%.*]] = load [[INT]], [[INT]]* @"$s16class_resilience33ClassWithResilientlySizedPropertyC5colors5Int32VvpWvd" // CHECK-NEXT: [[PTR:%.*]] = bitcast %T16class_resilience33ClassWithResilientlySizedPropertyC* %0 to i8* // CHECK-NEXT: [[FIELD_ADDR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], [[INT]] [[OFFSET]] @@ -303,7 +303,7 @@ public class ClassWithResilientThenEmpty { // ClassWithIndirectResilientEnum.color getter -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience30ClassWithIndirectResilientEnumC5colors5Int32Vvg"(%T16class_resilience30ClassWithIndirectResilientEnumC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience30ClassWithIndirectResilientEnumC5colors5Int32Vvg"(%T16class_resilience30ClassWithIndirectResilientEnumC* swiftself %0) // CHECK: [[FIELD_PTR:%.*]] = getelementptr inbounds %T16class_resilience30ClassWithIndirectResilientEnumC, %T16class_resilience30ClassWithIndirectResilientEnumC* %0, i32 0, i32 2 // CHECK-NEXT: [[FIELD_PAYLOAD:%.*]] = getelementptr inbounds %Ts5Int32V, %Ts5Int32V* [[FIELD_PTR]], i32 0, i32 0 // CHECK-NEXT: [[FIELD_VALUE:%.*]] = load i32, i32* [[FIELD_PAYLOAD]] @@ -312,7 +312,7 @@ public class ClassWithResilientThenEmpty { // ResilientChild.field getter -// CHECK-LABEL: define hidden swiftcc i32 @"$s16class_resilience14ResilientChildC5fields5Int32Vvg"(%T16class_resilience14ResilientChildC* swiftself) +// CHECK-LABEL: define hidden swiftcc i32 @"$s16class_resilience14ResilientChildC5fields5Int32Vvg"(%T16class_resilience14ResilientChildC* swiftself %0) // CHECK: [[OFFSET:%.*]] = load [[INT]], [[INT]]* @"$s16class_resilience14ResilientChildC5fields5Int32VvpWvd" // CHECK-NEXT: [[PTR:%.*]] = bitcast %T16class_resilience14ResilientChildC* %0 to i8* // CHECK-NEXT: [[FIELD_ADDR:%.*]] = getelementptr inbounds i8, i8* [[PTR]], [[INT]] [[OFFSET]] @@ -325,7 +325,7 @@ public class ClassWithResilientThenEmpty { // ResilientGenericChild.field getter -// CHECK-LABEL: define hidden swiftcc i32 @"$s16class_resilience21ResilientGenericChildC5fields5Int32Vvg"(%T16class_resilience21ResilientGenericChildC* swiftself) +// CHECK-LABEL: define hidden swiftcc i32 @"$s16class_resilience21ResilientGenericChildC5fields5Int32Vvg"(%T16class_resilience21ResilientGenericChildC* swiftself %0) // FIXME: we could eliminate the unnecessary isa load by lazily emitting // metadata sources in EmitPolymorphicParameters @@ -352,7 +352,7 @@ public class ClassWithResilientThenEmpty { // MyResilientChild.field getter -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience16MyResilientChildC5fields5Int32Vvg"(%T16class_resilience16MyResilientChildC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @"$s16class_resilience16MyResilientChildC5fields5Int32Vvg"(%T16class_resilience16MyResilientChildC* swiftself %0) // CHECK: [[FIELD_ADDR:%.*]] = getelementptr inbounds %T16class_resilience16MyResilientChildC, %T16class_resilience16MyResilientChildC* %0, i32 0, i32 2 // CHECK-NEXT: [[PAYLOAD_ADDR:%.*]] = getelementptr inbounds %Ts5Int32V, %Ts5Int32V* [[FIELD_ADDR]], i32 0, i32 0 // CHECK-NEXT: [[RESULT:%.*]] = load i32, i32* [[PAYLOAD_ADDR]] @@ -361,7 +361,7 @@ public class ClassWithResilientThenEmpty { // ResilientGenericOutsideParent.genericExtensionMethod() -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s15resilient_class29ResilientGenericOutsideParentC0B11_resilienceE22genericExtensionMethodxmyF"(%T15resilient_class29ResilientGenericOutsideParentC* swiftself) #0 { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s15resilient_class29ResilientGenericOutsideParentC0B11_resilienceE22genericExtensionMethodxmyF"(%T15resilient_class29ResilientGenericOutsideParentC* swiftself %0) {{.*}} { // CHECK: [[ISA_ADDR:%.*]] = bitcast %T15resilient_class29ResilientGenericOutsideParentC* %0 to %swift.type** // CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_ADDR]] // CHECK: [[BASE:%.*]] = load [[INT]], [[INT]]* getelementptr inbounds ([[BOUNDS]], [[BOUNDS]]* @"$s15resilient_class29ResilientGenericOutsideParentCMo", i32 0, i32 0) @@ -396,7 +396,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientProperty metadata initialization function -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience26ClassWithResilientPropertyCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience26ClassWithResilientPropertyCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [3 x i8**] // CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* %0 to [[INT]]* @@ -441,7 +441,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientProperty method lookup function -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience26ClassWithResilientPropertyCMu"(%swift.type*, %swift.method_descriptor*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience26ClassWithResilientPropertyCMu"(%swift.type* %0, %swift.method_descriptor* %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[RESULT:%.*]] = call i8* @swift_lookUpClassMethod(%swift.type* %0, %swift.method_descriptor* %1, %swift.type_descriptor* bitcast (<{{.*}}>* @"$s16class_resilience26ClassWithResilientPropertyCMn" to %swift.type_descriptor*)) // CHECK-NEXT: ret i8* [[RESULT]] @@ -472,7 +472,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientlySizedProperty metadata initialization function -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience33ClassWithResilientlySizedPropertyCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience33ClassWithResilientlySizedPropertyCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [2 x i8**] // CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* %0 to [[INT]]* @@ -517,7 +517,7 @@ public class ClassWithResilientThenEmpty { // ClassWithResilientlySizedProperty method lookup function -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience33ClassWithResilientlySizedPropertyCMu"(%swift.type*, %swift.method_descriptor*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience33ClassWithResilientlySizedPropertyCMu"(%swift.type* %0, %swift.method_descriptor* %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[RESULT:%.*]] = call i8* @swift_lookUpClassMethod(%swift.type* %0, %swift.method_descriptor* %1, %swift.type_descriptor* bitcast (<{{.*}}>* @"$s16class_resilience33ClassWithResilientlySizedPropertyCMn" to %swift.type_descriptor*)) // CHECK-NEXT: ret i8* [[RESULT]] @@ -526,7 +526,7 @@ public class ClassWithResilientThenEmpty { // ResilientChild metadata initialization function -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience14ResilientChildCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience14ResilientChildCMr"(%swift.type* %0, i8* %1, i8** %2) // Initialize field offset vector... // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* %0, [[INT]] 0, [[INT]] 1, i8*** {{.*}}, [[INT]]* {{.*}}) @@ -536,7 +536,7 @@ public class ClassWithResilientThenEmpty { // ResilientChild method lookup function -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience14ResilientChildCMu"(%swift.type*, %swift.method_descriptor*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience14ResilientChildCMu"(%swift.type* %0, %swift.method_descriptor* %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[RESULT:%.*]] = call i8* @swift_lookUpClassMethod(%swift.type* %0, %swift.method_descriptor* %1, %swift.type_descriptor* bitcast (<{{.*}}>* @"$s16class_resilience14ResilientChildCMn" to %swift.type_descriptor*)) // CHECK-NEXT: ret i8* [[RESULT]] @@ -545,7 +545,7 @@ public class ClassWithResilientThenEmpty { // ResilientChild.field setter dispatch thunk -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience14ResilientChildC5fields5Int32VvsTj"(i32, %T16class_resilience14ResilientChildC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience14ResilientChildC5fields5Int32VvsTj"(i32 %0, %T16class_resilience14ResilientChildC* swiftself %1) // CHECK: [[ISA_ADDR:%.*]] = getelementptr inbounds %T16class_resilience14ResilientChildC, %T16class_resilience14ResilientChildC* %1, i32 0, i32 0, i32 0 // CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_ADDR]] // CHECK-NEXT: [[BASE:%.*]] = load [[INT]], [[INT]]* getelementptr inbounds ([[BOUNDS]], [[BOUNDS]]* @"$s16class_resilience14ResilientChildCMo", i32 0, i32 0) @@ -560,12 +560,12 @@ public class ClassWithResilientThenEmpty { // ResilientGenericChild metadata initialization function -// CHECK-LABEL: define internal %swift.type* @"$s16class_resilience21ResilientGenericChildCMi"(%swift.type_descriptor*, i8**, i8*) +// CHECK-LABEL: define internal %swift.type* @"$s16class_resilience21ResilientGenericChildCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK: ret %swift.type* [[METADATA]] // CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s16class_resilience21ResilientGenericChildCMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* [[METADATA]], [[INT]] 0, // CHECK: ret %swift.metadata_response @@ -573,7 +573,7 @@ public class ClassWithResilientThenEmpty { // ResilientGenericChild method lookup function -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience21ResilientGenericChildCMu"(%swift.type*, %swift.method_descriptor*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @"$s16class_resilience21ResilientGenericChildCMu"(%swift.type* %0, %swift.method_descriptor* %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[RESULT:%.*]] = call i8* @swift_lookUpClassMethod(%swift.type* %0, %swift.method_descriptor* %1, %swift.type_descriptor* bitcast (<{{.*}}>* @"$s16class_resilience21ResilientGenericChildCMn" to %swift.type_descriptor*)) // CHECK-NEXT: ret i8* [[RESULT]] diff --git a/test/IRGen/class_resilience_objc.swift b/test/IRGen/class_resilience_objc.swift index 99294cdb147e9..9f3bbc11aa7b8 100644 --- a/test/IRGen/class_resilience_objc.swift +++ b/test/IRGen/class_resilience_objc.swift @@ -21,7 +21,7 @@ public class FixedLayoutObjCSubclass : NSObject { public final var field: Int32 = 0 }; -// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc29testConstantDirectFieldAccessyyAA23FixedLayoutObjCSubclassCF"(%T21class_resilience_objc23FixedLayoutObjCSubclassC*) +// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc29testConstantDirectFieldAccessyyAA23FixedLayoutObjCSubclassCF"(%T21class_resilience_objc23FixedLayoutObjCSubclassC* %0) // CHECK: [[OFFSET:%.*]] = load [[INT]], [[INT]]* @"$s21class_resilience_objc23FixedLayoutObjCSubclassC5fields5Int32VvpWvd" // CHECK-NEXT: [[OBJECT:%.*]] = bitcast %T21class_resilience_objc23FixedLayoutObjCSubclassC* %0 to i8* // CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds i8, i8* [[OBJECT]], [[INT]] [[OFFSET]] @@ -40,7 +40,7 @@ public class NonFixedLayoutObjCSubclass : NSCoder { public final var field: Int32 = 0 } -// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc32testNonConstantDirectFieldAccessyyAA0E23FixedLayoutObjCSubclassCF"(%T21class_resilience_objc26NonFixedLayoutObjCSubclassC*) +// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc32testNonConstantDirectFieldAccessyyAA0E23FixedLayoutObjCSubclassCF"(%T21class_resilience_objc26NonFixedLayoutObjCSubclassC* %0) // CHECK: [[OFFSET:%.*]] = load [[INT]], [[INT]]* @"$s21class_resilience_objc26NonFixedLayoutObjCSubclassC5fields5Int32VvpWvd" // CHECK-NEXT: [[OBJECT:%.*]] = bitcast %T21class_resilience_objc26NonFixedLayoutObjCSubclassC* %0 to i8* // CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds i8, i8* [[OBJECT]], [[INT]] [[OFFSET]] @@ -62,7 +62,7 @@ public class GenericObjCSubclass : NSCoder { } } -// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc31testConstantIndirectFieldAccessyyAA19GenericObjCSubclassCyxGlF"(%T21class_resilience_objc19GenericObjCSubclassC*) +// CHECK-LABEL: define hidden swiftcc void @"$s21class_resilience_objc31testConstantIndirectFieldAccessyyAA19GenericObjCSubclassCyxGlF"(%T21class_resilience_objc19GenericObjCSubclassC* %0) // FIXME: we could eliminate the unnecessary isa load by lazily emitting // metadata sources in EmitPolymorphicParameters diff --git a/test/IRGen/class_resilience_thunks.swift b/test/IRGen/class_resilience_thunks.swift index 1a9e706aa45dc..b72f29721c764 100644 --- a/test/IRGen/class_resilience_thunks.swift +++ b/test/IRGen/class_resilience_thunks.swift @@ -8,7 +8,7 @@ import resilient_class_thunks -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks21testDispatchThunkBase1b1ty010resilient_a1_C00G0CyxG_xtlF"(%T22resilient_class_thunks4BaseC*, %swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks21testDispatchThunkBase1b1ty010resilient_a1_C00G0CyxG_xtlF"(%T22resilient_class_thunks4BaseC* %0, %swift.opaque* noalias nocapture %1) public func testDispatchThunkBase(b: Base, t: T) { // CHECK: call swiftcc void @"$s22resilient_class_thunks4BaseC6takesTyyxFTj"(%swift.opaque* noalias nocapture {{%.*}}, %T22resilient_class_thunks4BaseC* swiftself %0) @@ -23,7 +23,7 @@ public func testDispatchThunkBase(b: Base, t: T) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks24testDispatchThunkDerived1dy010resilient_a1_C00G0C_tF"(%T22resilient_class_thunks7DerivedC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks24testDispatchThunkDerived1dy010resilient_a1_C00G0C_tF"(%T22resilient_class_thunks7DerivedC* %0) public func testDispatchThunkDerived(d: Derived) { // CHECK: call swiftcc void @"$s22resilient_class_thunks4BaseC6takesTyyxFTj"(%swift.opaque* noalias nocapture dereferenceable({{4|8}}) {{%.*}}, %T22resilient_class_thunks4BaseC* swiftself {{%.*}}) @@ -48,7 +48,7 @@ open class MyDerived : Base { open override func takesReference(_: Object) {} } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks27testDispatchThunkMyOverride1d1oyAA0G7DerivedC_010resilient_a1_C06ObjectCtF"(%T23class_resilience_thunks9MyDerivedC*, %T22resilient_class_thunks6ObjectC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s23class_resilience_thunks27testDispatchThunkMyOverride1d1oyAA0G7DerivedC_010resilient_a1_C06ObjectCtF"(%T23class_resilience_thunks9MyDerivedC* %0, %T22resilient_class_thunks6ObjectC* %1) public func testDispatchThunkMyOverride(d: MyDerived, o: Object) { // CHECK: call swiftcc void @"$s22resilient_class_thunks4BaseC14takesReferenceyyAA6ObjectCFTj" d.takesReference(o) diff --git a/test/IRGen/class_update_callback_with_fixed_layout.sil b/test/IRGen/class_update_callback_with_fixed_layout.sil index e7570f1f749c2..6866adee2f953 100644 --- a/test/IRGen/class_update_callback_with_fixed_layout.sil +++ b/test/IRGen/class_update_callback_with_fixed_layout.sil @@ -180,7 +180,7 @@ bb0: // Accessing a field whose offset depends on resilient types should // use the field offset global. -// CHECK-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i64 @accessClassWithResilientField(%T39class_update_callback_with_fixed_layout23ClassWithResilientFieldC*) +// CHECK-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i64 @accessClassWithResilientField(%T39class_update_callback_with_fixed_layout23ClassWithResilientFieldC* %0) sil @accessClassWithResilientField : $@convention(thin) (@guaranteed ClassWithResilientField) -> Int { bb0(%0 : $ClassWithResilientField): @@ -202,7 +202,7 @@ bb0(%0 : $ClassWithResilientField): // Objective-C metadata update callback function for ClassWithResilientField: -// CHECK-LABEL: define internal %objc_class* @"$s39class_update_callback_with_fixed_layout23ClassWithResilientFieldCMU"(%objc_class*, i8*) +// CHECK-LABEL: define internal %objc_class* @"$s39class_update_callback_with_fixed_layout23ClassWithResilientFieldCMU"(%objc_class* %0, i8* %1) // CHECK: entry: // CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s39class_update_callback_with_fixed_layout23ClassWithResilientFieldCMa"(i64 0) // CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 @@ -212,7 +212,7 @@ bb0(%0 : $ClassWithResilientField): // Metadata initialization function for ClassWithResilientField calls swift_updateClassMetadata2(): -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s39class_update_callback_with_fixed_layout23ClassWithResilientFieldCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s39class_update_callback_with_fixed_layout23ClassWithResilientFieldCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [3 x i8**] @@ -258,7 +258,7 @@ bb0(%0 : $ClassWithResilientField): // Metadata initialization function for SubclassOfClassWithResilientField: -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s39class_update_callback_with_fixed_layout33SubclassOfClassWithResilientFieldCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s39class_update_callback_with_fixed_layout33SubclassOfClassWithResilientFieldCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [0 x i8**] diff --git a/test/IRGen/class_update_callback_with_stub.swift b/test/IRGen/class_update_callback_with_stub.swift index dfd6c835e6298..3652209a245b7 100644 --- a/test/IRGen/class_update_callback_with_stub.swift +++ b/test/IRGen/class_update_callback_with_stub.swift @@ -127,7 +127,7 @@ import resilient_objc_class // -- Metadata update callbacks referenced from class stubs -// CHECK-LABEL: define internal %objc_class* @"$s31class_update_callback_with_stub17ResilientSubclassCMU"(%objc_class*, i8*) +// CHECK-LABEL: define internal %objc_class* @"$s31class_update_callback_with_stub17ResilientSubclassCMU"(%objc_class* %0, i8* %1) // CHECK: entry: // CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s31class_update_callback_with_stub17ResilientSubclassCMa"([[INT]] 0) // CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 @@ -135,7 +135,7 @@ import resilient_objc_class // CHECK-NEXT: ret %objc_class* [[CLASS]] // CHECK-NEXT: } -// CHECK-LABEL: define internal %objc_class* @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMU"(%objc_class*, i8*) +// CHECK-LABEL: define internal %objc_class* @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMU"(%objc_class* %0, i8* %1) // CHECK: entry: // CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMa"([[INT]] 0) // CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 diff --git a/test/IRGen/class_update_callback_without_fixed_layout.sil b/test/IRGen/class_update_callback_without_fixed_layout.sil index 7888a9d7e09ab..3b62de8a6f397 100644 --- a/test/IRGen/class_update_callback_without_fixed_layout.sil +++ b/test/IRGen/class_update_callback_without_fixed_layout.sil @@ -185,8 +185,8 @@ bb0: // Accessing a field whose offset depends on resilient types should // use the field offset global. -// CHECK-32-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i32 @accessClassWithResilientField(%T42class_update_callback_without_fixed_layout23ClassWithResilientFieldC*) -// CHECK-64-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i64 @accessClassWithResilientField(%T42class_update_callback_without_fixed_layout23ClassWithResilientFieldC*) +// CHECK-32-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i32 @accessClassWithResilientField(%T42class_update_callback_without_fixed_layout23ClassWithResilientFieldC* %0) +// CHECK-64-LABEL: define swiftcc {{(dllexport )?}}{{(protected )?}}i64 @accessClassWithResilientField(%T42class_update_callback_without_fixed_layout23ClassWithResilientFieldC* %0) sil @accessClassWithResilientField : $@convention(thin) (@guaranteed ClassWithResilientField) -> Int { bb0(%0 : $ClassWithResilientField): @@ -208,9 +208,9 @@ bb0(%0 : $ClassWithResilientField): // Objective-C metadata update callback function for ClassWithResilientField: -// CHECK-OLD-NOT: define internal %objc_class* @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMU"(%objc_class*, i8*) +// CHECK-OLD-NOT: define internal %objc_class* @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMU"(%objc_class* %0, i8* %1) -// CHECK-NEW-LABEL: define internal %objc_class* @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMU"(%objc_class*, i8*) +// CHECK-NEW-LABEL: define internal %objc_class* @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMU"(%objc_class* %0, i8* %1) // CHECK-NEW: entry: // CHECK-NEW-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMa"([[INT]] 0) // CHECK-NEW-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 @@ -221,7 +221,7 @@ bb0(%0 : $ClassWithResilientField): // Metadata initialization function for ClassWithResilientField calls swift_updateClassMetadata2() // with the new deployment target: -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s42class_update_callback_without_fixed_layout23ClassWithResilientFieldCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [3 x i8**] @@ -270,7 +270,7 @@ bb0(%0 : $ClassWithResilientField): // Metadata initialization function for SubclassOfClassWithResilientField: -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s42class_update_callback_without_fixed_layout33SubclassOfClassWithResilientFieldCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s42class_update_callback_without_fixed_layout33SubclassOfClassWithResilientFieldCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: entry: // CHECK-NEXT: [[FIELDS:%.*]] = alloca [0 x i8**] diff --git a/test/IRGen/closure.swift b/test/IRGen/closure.swift index a0efd962c4d53..bcdb8441b0ca3 100644 --- a/test/IRGen/closure.swift +++ b/test/IRGen/closure.swift @@ -16,7 +16,7 @@ func a(i i: Int) -> (Int) -> Int { } // -- Closure entry point -// CHECK: define internal swiftcc i64 @"$s7closure1a1iS2icSi_tFS2icfU_"(i64, i64) +// CHECK: define internal swiftcc i64 @"$s7closure1a1iS2icSi_tFS2icfU_"(i64 %0, i64 %1) protocol Ordinable { func ord() -> Int @@ -27,14 +27,14 @@ func b(seq seq: T) -> (Int) -> Int { } // -- partial_apply stub -// CHECK: define internal swiftcc i64 @"$s7closure1a1iS2icSi_tFS2icfU_TA"(i64, %swift.refcounted* swiftself) +// CHECK: define internal swiftcc i64 @"$s7closure1a1iS2icSi_tFS2icfU_TA"(i64 %0, %swift.refcounted* swiftself %1) // CHECK: } // -- Closure entry point -// CHECK: define internal swiftcc i64 @"$s7closure1b3seqS2icx_tAA9OrdinableRzlFS2icfU_"(i64, %swift.refcounted*, %swift.type* %T, i8** %T.Ordinable) {{.*}} { +// CHECK: define internal swiftcc i64 @"$s7closure1b3seqS2icx_tAA9OrdinableRzlFS2icfU_"(i64 %0, %swift.refcounted* %1, %swift.type* %T, i8** %T.Ordinable) {{.*}} { // -- partial_apply stub -// CHECK: define internal swiftcc i64 @"$s7closure1b3seqS2icx_tAA9OrdinableRzlFS2icfU_TA"(i64, %swift.refcounted* swiftself) {{.*}} { +// CHECK: define internal swiftcc i64 @"$s7closure1b3seqS2icx_tAA9OrdinableRzlFS2icfU_TA"(i64 %0, %swift.refcounted* swiftself %1) {{.*}} { // CHECK: entry: // CHECK: [[CONTEXT:%.*]] = bitcast %swift.refcounted* %1 to <{ %swift.refcounted, [16 x i8], %swift.refcounted* }>* // CHECK: [[BINDINGSADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted, [16 x i8], %swift.refcounted* }>, <{ %swift.refcounted, [16 x i8], %swift.refcounted* }>* [[CONTEXT]], i32 0, i32 1 @@ -50,7 +50,7 @@ func b(seq seq: T) -> (Int) -> Int { // CHECK: } // -- Boxing of tuples with generic elements -// CHECK: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure14captures_tuple1xx_q_tycx_q_t_tr0_lF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T, %swift.type* %U) +// CHECK: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure14captures_tuple1xx_q_tycx_q_t_tr0_lF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, %swift.type* %U) func captures_tuple(x x: (T, U)) -> () -> (T, U) { // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @swift_getTupleTypeMetadata2(i64 0, %swift.type* %T, %swift.type* %U, i8* null, i8** null) // CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 @@ -70,9 +70,9 @@ func no_capture_descriptor(_ c: C, _ d: C, _ e: C, _ f: C, _ g: C) { useClosure( { _ = c ; _ = d ; _ = e ; _ = f ; _ = g }) } -// CHECK-LABEL: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure9letEscape1fyycyyXE_tF"(i8*, %swift.opaque*) +// CHECK-LABEL: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure9letEscape1fyycyyXE_tF"(i8* %0, %swift.opaque* %1) // CHECK: call i1 @swift_isEscapingClosureAtFileLocation(%swift.refcounted* {{.*}}, i8* getelementptr inbounds ({{.*}} [[FILENAME]] -// OPT-LABEL: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure9letEscape1fyycyyXE_tF"(i8*, %swift.opaque*) +// OPT-LABEL: define hidden swiftcc { i8*, %swift.refcounted* } @"$s7closure9letEscape1fyycyyXE_tF"(i8* %0, %swift.opaque* %1) // OPT: call i1 @swift_isEscapingClosureAtFileLocation(%swift.refcounted* {{.*}}, i8* getelementptr inbounds ({{.*}} [[FILENAME]] func letEscape(f: () -> ()) -> () -> () { return withoutActuallyEscaping(f) { return $0 } diff --git a/test/IRGen/concrete_inherits_generic_base.swift b/test/IRGen/concrete_inherits_generic_base.swift index 714642a9c0a29..24f01cb197daf 100644 --- a/test/IRGen/concrete_inherits_generic_base.swift +++ b/test/IRGen/concrete_inherits_generic_base.swift @@ -81,6 +81,6 @@ presentBase(Derived(x: "two")) presentBase(Base(x: "two")) presentBase(Base(x: 2)) -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s3foo12SuperDerivedCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s3foo12SuperDerivedCMr"(%swift.type* %0, i8* %1, i8** %2) // -- ClassLayoutFlags = 0x100 (HasStaticVTable) // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* %0, [[INT]] 256, {{.*}}) diff --git a/test/IRGen/condfail_message.swift b/test/IRGen/condfail_message.swift index 5a5fc702cf465..d0a9c975e721b 100644 --- a/test/IRGen/condfail_message.swift +++ b/test/IRGen/condfail_message.swift @@ -2,7 +2,7 @@ // RUN: %target-swift-frontend -primary-file %s -g -Xllvm -enable-trap-debug-info -O -emit-ir | %FileCheck %s // REQUIRES: optimized_stdlib -// CHECK-LABEL: define hidden swiftcc i8 @"$s16condfail_message6testitys4Int8VADF"(i8) +// CHECK-LABEL: define hidden swiftcc i8 @"$s16condfail_message6testitys4Int8VADF"(i8 %0) // CHECK: call void @llvm.trap(), !dbg [[LOC:![0-9]+]] func testit(_ a: Int8) -> Int8 { diff --git a/test/IRGen/conditional_conformances_class_with_defaulted_method.swift b/test/IRGen/conditional_conformances_class_with_defaulted_method.swift index d1d041f571894..536ed8b80ad4e 100644 --- a/test/IRGen/conditional_conformances_class_with_defaulted_method.swift +++ b/test/IRGen/conditional_conformances_class_with_defaulted_method.swift @@ -12,4 +12,4 @@ extension Foo { } class Box {} extension Box: Foo where T: Foo {} -// CHECK-LABEL: define internal swiftcc void @"$s1x3BoxCyqd__GAA3FooA2aEP3baryyFTW"(%T1x3BoxC.0** noalias nocapture swiftself dereferenceable({{[48]}}), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define internal swiftcc void @"$s1x3BoxCyqd__GAA3FooA2aEP3baryyFTW"(%T1x3BoxC.0** noalias nocapture swiftself dereferenceable({{[48]}}) %0, %swift.type* %Self, i8** %SelfWitnessTable) diff --git a/test/IRGen/conformance_resilience.swift b/test/IRGen/conformance_resilience.swift index 0411285b9ea2e..a4cc2bc4e54a2 100644 --- a/test/IRGen/conformance_resilience.swift +++ b/test/IRGen/conformance_resilience.swift @@ -5,10 +5,10 @@ import resilient_protocol -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14useConformanceyyx18resilient_protocol22OtherResilientProtocolRzlF"(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.OtherResilientProtocol) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14useConformanceyyx18resilient_protocol22OtherResilientProtocolRzlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.OtherResilientProtocol) public func useConformance(_: T) {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14getConformanceyy18resilient_protocol7WrapperVyxGlF"(%swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14getConformanceyy18resilient_protocol7WrapperVyxGlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T) public func getConformance(_ w: Wrapper) { // CHECK: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s18resilient_protocol7WrapperVMa"([[INT]] 0, %swift.type* %T) // CHECK: [[META:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 @@ -18,7 +18,7 @@ public func getConformance(_ w: Wrapper) { useConformance(w) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14getConformanceyy18resilient_protocol15ConcreteWrapperVF"(%swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s22conformance_resilience14getConformanceyy18resilient_protocol15ConcreteWrapperVF"(%swift.opaque* noalias nocapture %0) public func getConformance(_ w: ConcreteWrapper) { // CHECK: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s18resilient_protocol15ConcreteWrapperVMa"([[INT]] 0) // CHECK: [[META:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0 diff --git a/test/IRGen/dependent_reabstraction.swift b/test/IRGen/dependent_reabstraction.swift index 6e18c2101c00e..f8a77405c8ee2 100644 --- a/test/IRGen/dependent_reabstraction.swift +++ b/test/IRGen/dependent_reabstraction.swift @@ -8,7 +8,7 @@ protocol A { } struct X : A { - // CHECK-LABEL: define internal swiftcc void @"$s23dependent_reabstraction1XVyxGAA1AA2aEP1byy1BQzFTW"(%swift.type** noalias nocapture dereferenceable({{.*}}), %T23dependent_reabstraction1XV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) + // CHECK-LABEL: define internal swiftcc void @"$s23dependent_reabstraction1XVyxGAA1AA2aEP1byy1BQzFTW"(%swift.type** noalias nocapture dereferenceable({{.*}}) %0, %T23dependent_reabstraction1XV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) func b(_ b: X.Type) { let x: Any = b markUsed(b as X.Type) diff --git a/test/IRGen/dllexport.swift b/test/IRGen/dllexport.swift index 1650aad3f62aa..cfd59e7734641 100644 --- a/test/IRGen/dllexport.swift +++ b/test/IRGen/dllexport.swift @@ -34,14 +34,14 @@ open class d { // CHECK-DAG-OPT: @"$s9dllexport1cCACycfc" = dllexport alias void (), void ()* @_swift_dead_method_stub // CHECK-DAG-OPT: @"$s9dllexport1cCACycfC" = dllexport alias void (), void ()* @_swift_dead_method_stub // CHECK-DAG: define dllexport swiftcc %swift.refcounted* @"$s9dllexport1cCfd"(%T9dllexport1cC*{{.*}}) -// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1cC* @"$s9dllexport1cCACycfc"(%T9dllexport1cC*) -// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1cC* @"$s9dllexport1cCACycfC"(%swift.type*) +// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1cC* @"$s9dllexport1cCACycfc"(%T9dllexport1cC* %0) +// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1cC* @"$s9dllexport1cCACycfC"(%swift.type* %0) // CHECK-DAG: define dllexport swiftcc i8* @"$s9dllexport2ciAA1cCvau"() -// CHECK-DAG-NO-OPT: define dllexport swiftcc void @"$s9dllexport1dC1m33_C57BA610BA35E21738CC992438E660E9LLyyF"(%T9dllexport1dC*) -// CHECK-DAG-NO-OPT: define dllexport swiftcc void @"$s9dllexport1dCfD"(%T9dllexport1dC*) +// CHECK-DAG-NO-OPT: define dllexport swiftcc void @"$s9dllexport1dC1m33_C57BA610BA35E21738CC992438E660E9LLyyF"(%T9dllexport1dC* %0) +// CHECK-DAG-NO-OPT: define dllexport swiftcc void @"$s9dllexport1dCfD"(%T9dllexport1dC* %0) // CHECK-DAG: define dllexport swiftcc %swift.refcounted* @"$s9dllexport1dCfd"(%T9dllexport1dC*{{.*}}) -// CHECK-DAG: define dllexport swiftcc %swift.metadata_response @"$s9dllexport1cCMa"(i32) -// CHECK-DAG: define dllexport swiftcc %swift.metadata_response @"$s9dllexport1dCMa"(i32) -// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1dC* @"$s9dllexport1dCACycfc"(%T9dllexport1dC*) -// CHECK-DAG-OPT: define dllexport swiftcc void @"$s9dllexport1dCfD"(%T9dllexport1dC*) +// CHECK-DAG: define dllexport swiftcc %swift.metadata_response @"$s9dllexport1cCMa"(i32 %0) +// CHECK-DAG: define dllexport swiftcc %swift.metadata_response @"$s9dllexport1dCMa"(i32 %0) +// CHECK-DAG-NO-OPT: define dllexport swiftcc %T9dllexport1dC* @"$s9dllexport1dCACycfc"(%T9dllexport1dC* %0) +// CHECK-DAG-OPT: define dllexport swiftcc void @"$s9dllexport1dCfD"(%T9dllexport1dC* %0) diff --git a/test/IRGen/dynamic_lookup.sil b/test/IRGen/dynamic_lookup.sil index b77c6ee2543af..c50239b17cdaf 100644 --- a/test/IRGen/dynamic_lookup.sil +++ b/test/IRGen/dynamic_lookup.sil @@ -50,7 +50,7 @@ bb0(%0 : $X): return %7 : $Int } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_lookup_br(%objc_object*) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_lookup_br(%objc_object* %0) sil @dynamic_lookup_br : $@convention(thin) (AnyObject) -> () { bb0(%0 : $AnyObject): %1 = alloc_box $<τ_0_0> { var τ_0_0 } @@ -80,7 +80,7 @@ bb3: return %43 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_lookup_static_br(%swift.type*) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_lookup_static_br(%swift.type* %0) sil @dynamic_lookup_static_br : $@convention(thin) (@thick AnyObject.Type) -> () { bb0(%0 : $@thick AnyObject.Type): // CHECK: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(g)", align {{(4|8)}} @@ -123,7 +123,7 @@ bb3: return %43 : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @_T1t16opt_to_subscriptFT3objPSo13AnyObject_1iSi_T_(%objc_object*, {{(i32|i64)}}) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @_T1t16opt_to_subscriptFT3objPSo13AnyObject_1iSi_T_(%objc_object* %0, {{(i32|i64)}} %1) sil @_T1t16opt_to_subscriptFT3objPSo13AnyObject_1iSi_T_ : $@convention(thin) (AnyObject, Int) -> () { bb0(%0 : $AnyObject, %1 : $Int): %2 = alloc_box $<τ_0_0> { var τ_0_0 } diff --git a/test/IRGen/dynamic_self_cast.swift b/test/IRGen/dynamic_self_cast.swift index f3d94f97d5d72..b194e7cbcd69b 100644 --- a/test/IRGen/dynamic_self_cast.swift +++ b/test/IRGen/dynamic_self_cast.swift @@ -5,7 +5,7 @@ // etc. public class SelfCasts { - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC02toD0yACXDACFZ"(%T17dynamic_self_cast9SelfCastsC*, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC02toD0yACXDACFZ"(%T17dynamic_self_cast9SelfCastsC* %0, %swift.type* swiftself %1) // CHECK: [[ARG:%.*]] = bitcast %T17dynamic_self_cast9SelfCastsC* %0 to i8* // CHECK: [[METATYPE:%.*]] = bitcast %swift.type* %1 to i8* // CHECK: call i8* @swift_dynamicCastClassUnconditional(i8* [[ARG]], i8* [[METATYPE]], i8* null, i32 0, i32 0) @@ -14,14 +14,14 @@ public class SelfCasts { return s as! Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC09genericToD0yACXDxlFZ"(%swift.opaque* noalias nocapture, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC09genericToD0yACXDxlFZ"(%swift.opaque* noalias nocapture %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %T, %swift.type* %1, {{.*}}) // CHECK: ret public static func genericToSelf(_ s: T) -> Self { return s as! Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC014classGenericToD0yACXDxRlzClFZ"(%swift.refcounted*, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %T17dynamic_self_cast9SelfCastsC* @"$s17dynamic_self_cast9SelfCastsC014classGenericToD0yACXDxRlzClFZ"(%swift.refcounted* %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: [[ARG:%.*]] = bitcast %swift.refcounted* %0 to i8* // CHECK: [[METATYPE:%.*]] = bitcast %swift.type* %1 to i8* // CHECK: call i8* @swift_dynamicCastClassUnconditional(i8* [[ARG]], i8* [[METATYPE]], i8* null, i32 0, i32 0) @@ -30,7 +30,7 @@ public class SelfCasts { return s as! Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s17dynamic_self_cast9SelfCastsC011genericFromD0xylFZ"(%swift.opaque* noalias nocapture sret, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s17dynamic_self_cast9SelfCastsC011genericFromD0xylFZ"(%swift.opaque* noalias nocapture sret %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %1, %swift.type* %T, {{.*}}) // CHECK: ret public static func genericFromSelf() -> T { @@ -38,7 +38,7 @@ public class SelfCasts { return s as! T } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %swift.refcounted* @"$s17dynamic_self_cast9SelfCastsC016classGenericFromD0xyRlzClFZ"(%swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc %swift.refcounted* @"$s17dynamic_self_cast9SelfCastsC016classGenericFromD0xyRlzClFZ"(%swift.type* %T, %swift.type* swiftself %0) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %0, %swift.type* %T, {{.*}}) // CHECK: ret public static func classGenericFromSelf() -> T { @@ -46,7 +46,7 @@ public class SelfCasts { return s as! T } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC02toD11ConditionalyACXDSgACFZ"(%T17dynamic_self_cast9SelfCastsC*, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC02toD11ConditionalyACXDSgACFZ"(%T17dynamic_self_cast9SelfCastsC* %0, %swift.type* swiftself %1) // CHECK: [[ARG:%.*]] = bitcast %T17dynamic_self_cast9SelfCastsC* %0 to i8* // CHECK: [[METATYPE:%.*]] = bitcast %swift.type* %1 to i8* // CHECK: call i8* @swift_dynamicCastClass(i8* [[ARG]], i8* [[METATYPE]]) @@ -55,14 +55,14 @@ public class SelfCasts { return s as? Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC09genericToD11ConditionalyACXDSgxlFZ"(%swift.opaque* noalias nocapture, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC09genericToD11ConditionalyACXDSgxlFZ"(%swift.opaque* noalias nocapture %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %T, %swift.type* %1, {{.*}}) // CHECK: ret public static func genericToSelfConditional(_ s: T) -> Self? { return s as? Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC014classGenericToD11ConditionalyACXDSgxRlzClFZ"(%swift.refcounted*, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC014classGenericToD11ConditionalyACXDSgxRlzClFZ"(%swift.refcounted* %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: [[ARG:%.*]] = bitcast %swift.refcounted* %0 to i8* // CHECK: [[METATYPE:%.*]] = bitcast %swift.type* %1 to i8* // CHECK: call i8* @swift_dynamicCastClass(i8* [[ARG]], i8* [[METATYPE]]) @@ -71,7 +71,7 @@ public class SelfCasts { return s as? Self } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s17dynamic_self_cast9SelfCastsC011genericFromD11ConditionalxSgylFZ"(%TSq* noalias nocapture sret, %swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s17dynamic_self_cast9SelfCastsC011genericFromD11ConditionalxSgylFZ"(%TSq* noalias nocapture sret %0, %swift.type* %T, %swift.type* swiftself %1) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %1, %swift.type* %T, {{.*}}) // CHECK: ret public static func genericFromSelfConditional() -> T? { @@ -79,7 +79,7 @@ public class SelfCasts { return s as? T } - // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC016classGenericFromD11ConditionalxSgyRlzClFZ"(%swift.type* %T, %swift.type* swiftself) + // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc {{i32|i64}} @"$s17dynamic_self_cast9SelfCastsC016classGenericFromD11ConditionalxSgyRlzClFZ"(%swift.type* %T, %swift.type* swiftself %0) // CHECK: call i1 @swift_dynamicCast(%swift.opaque* {{%.*}}, %swift.opaque* {{%.*}}, %swift.type* %0, %swift.type* %T, {{.*}}) // CHECK: ret public static func classGenericFromSelfConditional() -> T? { diff --git a/test/IRGen/dynamic_self_metadata.swift b/test/IRGen/dynamic_self_metadata.swift index c03307c070e96..ad62af6990a5f 100644 --- a/test/IRGen/dynamic_self_metadata.swift +++ b/test/IRGen/dynamic_self_metadata.swift @@ -27,17 +27,17 @@ struct G : P { class C { class func fromMetatype() -> Self? { return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC12fromMetatypeACXDSgyFZ"(%swift.type* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC12fromMetatypeACXDSgyFZ"(%swift.type* swiftself %0) // CHECK: ret i64 0 func fromInstance() -> Self? { return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC12fromInstanceACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC12fromInstanceACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself %0) // CHECK: ret i64 0 func dynamicSelfArgument() -> Self? { return id(nil) } - // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC0A12SelfArgumentACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC0A12SelfArgumentACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself %0) // CHECK: [[GEP1:%.+]] = getelementptr {{.*}} %0 // CHECK: [[TYPE1:%.+]] = load {{.*}} [[GEP1]] // CHECK: [[T0:%.+]] = call swiftcc %swift.metadata_response @"$sSqMa"(i64 0, %swift.type* [[TYPE1]]) @@ -48,7 +48,7 @@ class C { _ = G(t: self).f() return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC0A18SelfConformingTypeACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s21dynamic_self_metadata1CC0A18SelfConformingTypeACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself %0) // CHECK: [[SELF_GEP:%.+]] = getelementptr {{.*}} %0 // CHECK: [[SELF_TYPE:%.+]] = load {{.*}} [[SELF_GEP]] // CHECK: [[METADATA_RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s21dynamic_self_metadata1GVMa"(i64 0, %swift.type* [[SELF_TYPE]]) diff --git a/test/IRGen/dynamic_self_metadata_future.swift b/test/IRGen/dynamic_self_metadata_future.swift index fd87ebe349c70..18e74356b6d30 100644 --- a/test/IRGen/dynamic_self_metadata_future.swift +++ b/test/IRGen/dynamic_self_metadata_future.swift @@ -28,17 +28,17 @@ struct G : P { class C { class func fromMetatype() -> Self? { return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC12fromMetatypeACXDSgyFZ"(%swift.type* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC12fromMetatypeACXDSgyFZ"(%swift.type* swiftself %0) // CHECK: ret i64 0 func fromInstance() -> Self? { return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC12fromInstanceACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC12fromInstanceACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself %0) // CHECK: ret i64 0 func dynamicSelfArgument() -> Self? { return id(nil) } - // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC0A12SelfArgumentACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC0A12SelfArgumentACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself %0) // CHECK: [[GEP1:%.+]] = getelementptr {{.*}} %0 // CHECK: [[TYPE1:%.+]] = load {{.*}} [[GEP1]] // CHECK: [[T0:%.+]] = call swiftcc %swift.metadata_response @"$sSqMa"(i64 0, %swift.type* [[TYPE1]]) @@ -49,7 +49,7 @@ class C { _ = G(t: self).f() return nil } - // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC0A18SelfConformingTypeACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself) + // CHECK-LABEL: define hidden swiftcc i64 @"$s28dynamic_self_metadata_future1CC0A18SelfConformingTypeACXDSgyF"(%T28dynamic_self_metadata_future1CC* swiftself %0) // CHECK: [[SELF_GEP:%.+]] = getelementptr {{.*}} %0 // CHECK: [[SELF_TYPE:%.+]] = load {{.*}} [[SELF_GEP]] // CHECK: call i8** @swift_getWitnessTable( diff --git a/test/IRGen/enum.sil b/test/IRGen/enum.sil index 25478dc0566c8..322cd651b296e 100644 --- a/test/IRGen/enum.sil +++ b/test/IRGen/enum.sil @@ -201,8 +201,8 @@ enum DynamicSingleton { case value(T) } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch(i64, i64) {{.*}} { -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch(%T4enum9SingletonO* noalias nocapture dereferenceable(16)) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch(i64 %0, i64 %1) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch(%T4enum9SingletonO* noalias nocapture dereferenceable(16) %0) {{.*}} { sil @singleton_switch : $(Singleton) -> () { // CHECK-64: entry: // CHECK-32: entry: @@ -220,8 +220,8 @@ dest: return %x : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_arg(i64, i64) {{.*}} { -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_arg(%T4enum9SingletonO* noalias nocapture dereferenceable(16)) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_arg(i64 %0, i64 %1) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_arg(%T4enum9SingletonO* noalias nocapture dereferenceable(16) %0) {{.*}} { sil @singleton_switch_arg : $(Singleton) -> () { // CHECK-64: entry: // CHECK-32: entry: @@ -242,7 +242,7 @@ dest(%u2 : $(Builtin.Int64, Builtin.Int64)): return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_indirect(%T4enum9SingletonO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_switch_indirect(%T4enum9SingletonO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: entry: // CHECK: br label %[[DEST:[0-9]+]] // CHECK: [[DEST]]: @@ -258,13 +258,13 @@ dest: return %x : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @singleton_inject(i64, i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64 } @singleton_inject(i64 %0, i64 %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[A:%.*]] = insertvalue { i64, i64 } undef, i64 %0, 0 // CHECK-64: [[B:%.*]] = insertvalue { i64, i64 } [[A]], i64 %1, 1 // CHECK-64: ret { i64, i64 } [[B]] // CHECK-64: } -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_inject(%T4enum9SingletonO* noalias nocapture sret, i64, i64) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_inject(%T4enum9SingletonO* noalias nocapture sret %0, i64 %1, i64 %2) {{.*}} { // CHECK-32: entry: // CHECK-32: [[CAST:%.*]] = bitcast %T4enum9SingletonO* %0 to <{ i64, i64 }>* // CHECK-32: [[GEP1:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[CAST]], i32 0, i32 0 @@ -280,7 +280,7 @@ entry(%0 : $Builtin.Int64, %1 : $Builtin.Int64): return %u : $Singleton } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_inject_indirect(i64, i64, %T4enum9SingletonO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @singleton_inject_indirect(i64 %0, i64 %1, %T4enum9SingletonO* nocapture dereferenceable({{.*}}) %2) {{.*}} { // CHECK: entry: // CHECK: [[DATA_ADDR:%.*]] = bitcast %T4enum9SingletonO* %2 to <{ i64, i64 }>* // CHECK: [[DATA_0_ADDR:%.*]] = getelementptr inbounds <{ i64, i64 }>, <{ i64, i64 }>* [[DATA_ADDR]], i32 0, i32 0 @@ -314,7 +314,7 @@ sil @e : $@convention(thin) () -> () sil @f : $@convention(thin) () -> () -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch(i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch(i8 %0) {{.*}} { sil @no_payload_switch : $@convention(thin) (NoPayloads) -> () { // CHECK: entry: entry(%u : $NoPayloads): @@ -356,7 +356,7 @@ end: return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}}) %0) {{.*}} { sil @no_payload_switch_indirect : $@convention(thin) (@inout NoPayloads) -> () { entry(%u : $*NoPayloads): // CHECK: [[TAG_ADDR:%.*]] = getelementptr inbounds %T4enum10NoPayloadsO, %T4enum10NoPayloadsO* %0, i32 0, i32 0 @@ -405,7 +405,7 @@ entry: return %u : $NoPayloads } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_inject_z_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_inject_z_indirect(%T4enum10NoPayloadsO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: entry: // CHECK: [[TAG_ADDR:%.*]] = getelementptr inbounds %T4enum10NoPayloadsO, %T4enum10NoPayloadsO* %0, i32 0, i32 0 // CHECK: store i8 2, i8* [[TAG_ADDR]] @@ -428,7 +428,7 @@ enum NoPayloads2 { case y } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch_2(i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @no_payload_switch_2(i8 %0) {{.*}} { sil @no_payload_switch_2 : $@convention(thin) (NoPayloads2) -> () { // CHECK: entry: entry(%u : $NoPayloads2): @@ -474,8 +474,8 @@ enum SinglePayloadNoXI2 { case u } -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @select_enum([[WORD:i32]], i8) -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @select_enum([[WORD:i64]], i8) +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @select_enum([[WORD:i32]] %0, i8 %1) +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @select_enum([[WORD:i64]] %0, i8 %1) // CHECK: entry: // CHECK: [[TAG:%.*]] = trunc i8 %1 to i1 // CHECK: [[PAYLOAD:%.*]] = icmp eq [[WORD]] %0, 1 @@ -492,8 +492,8 @@ bb0(%0 : $SinglePayloadNoXI2): return %4 : $Builtin.Int1 } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch([[WORD:i64]], i8) {{.*}} { -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch([[WORD:i32]], i8) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch([[WORD:i64]] %0, i8 %1) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch([[WORD:i32]] %0, i8 %1) {{.*}} { sil @single_payload_no_xi_switch : $@convention(thin) (SinglePayloadNoXI2) -> () { // CHECK: entry: entry(%u : $SinglePayloadNoXI2): @@ -567,7 +567,7 @@ end: return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch_arg([[WORD]], i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_switch_arg([[WORD]] %0, i8 %1) {{.*}} { sil @single_payload_no_xi_switch_arg : $@convention(thin) (SinglePayloadNoXI2) -> () { // CHECK: entry: entry(%u : $SinglePayloadNoXI2): @@ -624,7 +624,7 @@ end: return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], i8 } @single_payload_no_xi_inject_x([[WORD]]) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], i8 } @single_payload_no_xi_inject_x([[WORD]] %0) {{.*}} { // CHECK: entry: // CHECK: [[A:%.*]] = insertvalue { [[WORD]], i8 } undef, [[WORD]] %0, 0 // CHECK: [[B:%.*]] = insertvalue { [[WORD]], i8 } [[A]], i8 0, 1 @@ -636,7 +636,7 @@ entry(%0 : $Builtin.Word): return %u : $SinglePayloadNoXI2 } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_inject_x_indirect([[WORD]], %T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_inject_x_indirect([[WORD]] %0, %T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK: entry: // CHECK: [[DATA_ADDR:%.*]] = bitcast %T4enum18SinglePayloadNoXI2O* %1 to [[WORD]]* // CHECK: store [[WORD]] %0, [[WORD]]* [[DATA_ADDR]] @@ -664,7 +664,7 @@ entry: return %u : $SinglePayloadNoXI2 } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_inject_y_indirect(%T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_no_xi_inject_y_indirect(%T4enum18SinglePayloadNoXI2O* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: entry: // CHECK: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum18SinglePayloadNoXI2O* %0 to [[WORD]]* // CHECK: store [[WORD]] 0, [[WORD]]* [[PAYLOAD_ADDR]] @@ -703,7 +703,7 @@ sil @int21_sink : $@convention(thin) (Builtin.Int21) -> () sil @int64_sink : $@convention(thin) (Builtin.Word) -> () // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack -// CHECK: ([[WORD]], [[WORD]], i8) {{.*}} { +// CHECK: ([[WORD]] %0, [[WORD]] %1, i8 %2) {{.*}} { sil @aggregate_single_payload_unpack : $@convention(thin) (AggregateSinglePayload) -> () { entry(%u : $AggregateSinglePayload): switch_enum %u : $AggregateSinglePayload, case #AggregateSinglePayload.x!enumelt.1: x_dest, default default_dest @@ -728,7 +728,7 @@ end: return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]] } @aggregate_single_payload_unsafe_unpack([[WORD]], [[WORD]], i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]] } @aggregate_single_payload_unsafe_unpack([[WORD]] %0, [[WORD]] %1, i8 %2) {{.*}} { // CHECK: [[A:%.*]] = insertvalue { [[WORD]], [[WORD]] } undef, [[WORD]] %0, 0 // CHECK: [[B:%.*]] = insertvalue { [[WORD]], [[WORD]] } [[A]], [[WORD]] %1, 1 // CHECK: ret { [[WORD]], [[WORD]] } [[B]] @@ -738,7 +738,7 @@ entry(%u : $AggregateSinglePayload): return %x : $(Builtin.Word, Builtin.Word) } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]], i8 } @aggregate_single_payload_inject([[WORD]], [[WORD]]) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]], i8 } @aggregate_single_payload_inject([[WORD]] %0, [[WORD]] %1) {{.*}} { // CHECK: entry: // CHECK: [[RES_0:%.*]] = insertvalue { [[WORD]], [[WORD]], i8 } undef, [[WORD]] %0, 0 // CHECK: [[RES_1:%.*]] = insertvalue { [[WORD]], [[WORD]], i8 } [[RES_0]], [[WORD]] %1, 1 @@ -762,8 +762,8 @@ enum AggregateSinglePayload2 { case z } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_2([[WORD]], [[WORD]], [[WORD]], [[WORD]]) {{.*}} { -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_2(%T4enum23AggregateSinglePayload2O* noalias nocapture dereferenceable(16)) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_2([[WORD]] %0, [[WORD]] %1, [[WORD]] %2, [[WORD]] %3) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_2(%T4enum23AggregateSinglePayload2O* noalias nocapture dereferenceable(16) %0) {{.*}} { sil @aggregate_single_payload_unpack_2 : $@convention(thin) (AggregateSinglePayload2) -> () { entry(%u : $AggregateSinglePayload2): switch_enum %u : $AggregateSinglePayload2, case #AggregateSinglePayload2.x!enumelt.1: x_dest, default default_dest @@ -784,7 +784,7 @@ end: return %x : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } @aggregate_single_payload_2_inject(i32, [[WORD]], [[WORD]], [[WORD]]) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } @aggregate_single_payload_2_inject(i32 %0, [[WORD]] %1, [[WORD]] %2, [[WORD]] %3) {{.*}} { // CHECK-64: entry: // CHECK-64: %4 = trunc i32 %0 to i21 // CHECK-64: %5 = zext i21 %4 to [[WORD]] @@ -794,7 +794,7 @@ end: // CHECK-64: %9 = insertvalue { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } %8, [[WORD]] %3, 3 // CHECK-64: ret { [[WORD]], [[WORD]], [[WORD]], [[WORD]] } %9 -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_2_inject(%T4enum23AggregateSinglePayload2O* noalias nocapture sret, i32, i32, i32, i32) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_2_inject(%T4enum23AggregateSinglePayload2O* noalias nocapture sret %0, i32 %1, i32 %2, i32 %3, i32 %4) {{.*}} { // CHECK-32: [[TRUNC:%.*]] = trunc i32 %1 to i21 // CHECK-32: [[ZEXT:%.*]] = zext i21 [[TRUNC]] to i32 // CHECK-32: [[CAST:%.*]] = bitcast %T4enum23AggregateSinglePayload2O* %0 to { i32, i32, i32, i32 }* @@ -817,7 +817,7 @@ enum AggregateSinglePayload3 { case z } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_3([[WORD]], [[WORD]]) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @aggregate_single_payload_unpack_3([[WORD]] %0, [[WORD]] %1) {{.*}} { sil @aggregate_single_payload_unpack_3 : $@convention(thin) (AggregateSinglePayload3) -> () { entry(%u : $AggregateSinglePayload3): switch_enum %u : $AggregateSinglePayload3, case #AggregateSinglePayload3.x!enumelt.1: x_dest, default default_dest @@ -845,7 +845,7 @@ end: return %x : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]] } @aggregate_single_payload_inject_x3(i32, [[WORD]]) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { [[WORD]], [[WORD]] } @aggregate_single_payload_inject_x3(i32 %0, [[WORD]] %1) {{.*}} { // CHECK: entry: // CHECK: [[TRUNC:%.*]] = trunc i32 %0 to i21 // CHECK: [[ZEXT:%.*]] = zext i21 [[TRUNC]] to [[WORD]] @@ -877,8 +877,8 @@ enum SinglePayloadSpareBit { case z } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch(i64) {{.*}} { -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch(i32, i32) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch(i64 %0) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch(i32 %0, i32 %1) {{.*}} { sil @single_payload_spare_bit_switch : $@convention(thin) (SinglePayloadSpareBit) -> () { // CHECK: entry: entry(%u : $SinglePayloadSpareBit): @@ -921,7 +921,7 @@ end: return %x : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch_arg(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_switch_arg(i64 %0) {{.*}} { sil @single_payload_spare_bit_switch_arg : $@convention(thin) (SinglePayloadSpareBit) -> () { // CHECK: entry: entry(%u : $SinglePayloadSpareBit): @@ -994,7 +994,7 @@ end: return %x : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @single_payload_spare_bit_inject_x(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @single_payload_spare_bit_inject_x(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[T:%.*]] = trunc i64 %0 to i63 // CHECK-64: [[A:%.*]] = zext i63 [[T]] to i64 @@ -1006,7 +1006,7 @@ entry(%0 : $Builtin.Int63): return %u : $SinglePayloadSpareBit } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_x_indirect(i64, %T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_x_indirect(i64 %0, %T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[T:%.*]] = trunc i64 %0 to i63 // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %1 to i63* @@ -1033,7 +1033,7 @@ entry: return %u : $SinglePayloadSpareBit } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_y_indirect(%T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_spare_bit_inject_y_indirect(%T4enum21SinglePayloadSpareBitO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum21SinglePayloadSpareBitO* %0 to i64* // -- 0x8000_0000_0000_0000 @@ -1072,7 +1072,7 @@ enum SinglePayloadNestedNested { case h } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_nested_switch(i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_nested_switch(i8 %0) {{.*}} { sil @single_payload_nested_switch : $(SinglePayloadNestedNested) -> () { entry(%u : $SinglePayloadNestedNested): // CHECK: switch i8 {{%.*}}, label {{%.*}} [ @@ -1134,7 +1134,7 @@ enum SinglePayloadClass { case w } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_switch(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_switch(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: switch i64 %0, label %[[DFLT:[0-9]+]] [ // CHECK-64: i64 0, label {{%.*}} @@ -1148,7 +1148,7 @@ enum SinglePayloadClass { // CHECK-64: [[DFLT]]: // CHECK-64: inttoptr [[WORD]] %0 to %T4enum1CC* -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_switch(i32) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_switch(i32 %0) {{.*}} { // CHECK-32: entry: // CHECK-32: switch i32 %0, label %[[DFLT:[0-9]+]] [ // CHECK-32: i32 0, label {{%.*}} @@ -1182,7 +1182,7 @@ enum SinglePayloadClassProtocol { case y, z, w } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i64, i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i64 %0, i64 %1) {{.*}} { // CHECK-64: switch i64 %0, label {{%.*}} [ // CHECK-64: i64 0, label {{%.*}} // CHECK-objc-64-simulator-false: i64 2, label {{%.*}} @@ -1197,7 +1197,7 @@ enum SinglePayloadClassProtocol { // CHECK-native-64: inttoptr i64 %0 to %swift.refcounted* // CHECK-64: inttoptr i64 %1 to i8** -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i32, i32) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i32 %0, i32 %1) {{.*}} { // CHECK-32: switch i32 %0, label {{%.*}} [ // CHECK-32: i32 0, label {{%.*}} // CHECK-32: i32 1, label {{%.*}} @@ -1232,7 +1232,7 @@ enum DynamicSinglePayload { case w } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_switch(%T4enum20DynamicSinglePayloadO* noalias nocapture, %swift.type* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_switch(%T4enum20DynamicSinglePayloadO* noalias nocapture %0, %swift.type* %T) {{.*}} { // CHECK: [[OPAQUE_ENUM:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque* // CHECK: [[TMP:%.*]] = bitcast %swift.type* %T to i8*** // CHECK: [[TMP2:%.*]] = getelementptr inbounds i8**, i8*** [[TMP]], i{{.*}} -1 @@ -1263,7 +1263,7 @@ end: return %v : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_inject_x(%T4enum20DynamicSinglePayloadO* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_inject_x(%T4enum20DynamicSinglePayloadO* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T) {{.*}} { // CHECK: [[OPAQUE_ENUM:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque* // CHECK: [[TMP:%.*]] = bitcast %swift.type* %T to i8*** // CHECK: [[TMP2:%.*]] = getelementptr inbounds i8**, i8*** [[TMP]], i{{.*}} -1 @@ -1279,7 +1279,7 @@ entry(%r : $*DynamicSinglePayload, %t : $*T): return %v : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_inject_y(%T4enum20DynamicSinglePayloadO* noalias nocapture sret, %swift.type* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_inject_y(%T4enum20DynamicSinglePayloadO* noalias nocapture sret %0, %swift.type* %T) {{.*}} { // CHECK: [[OPAQUE_ENUM:%.*]] = bitcast %T4enum20DynamicSinglePayloadO* %0 to %swift.opaque* // CHECK: [[TMP:%.*]] = bitcast %swift.type* %T to i8*** // CHECK: [[TMP2:%.*]] = getelementptr inbounds i8**, i8*** [[TMP]], i{{.*}} -1 @@ -1298,7 +1298,7 @@ entry(%r : $*DynamicSinglePayload): // -- Ensure instantiations of single-payload types with empty payloads work. // Bug discovered by Greg Parker. -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_empty_payload_switch(i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_empty_payload_switch(i8 %0) {{.*}} { // CHECK: switch i8 {{%.*}}, label {{.*}} [ // CHECK: i8 0, label {{.*}} // CHECK: i8 1, label {{.*}} @@ -1328,7 +1328,7 @@ end(%z : $()): return %z : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc i8 @dynamic_single_payload_empty_payload_load([[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc i8 @dynamic_single_payload_empty_payload_load([[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: entry: // CHECK: %1 = bitcast [[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* %0 to i8* // CHECK: %2 = load i8, i8* %1 @@ -1340,7 +1340,7 @@ entry(%p : $*DynamicSinglePayload<()>): return %x : $DynamicSinglePayload<()> } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_empty_payload_store([[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* nocapture dereferenceable({{.*}}), i8) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_single_payload_empty_payload_store([[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* nocapture dereferenceable({{.*}}) %0, i8 %1) {{.*}} { // CHECK: entry: // CHECK: %2 = bitcast [[DYNAMIC_SINGLE_EMPTY_PAYLOAD]]* %0 to i8* // CHECK: store i8 %1, i8* %2 @@ -1394,7 +1394,7 @@ enum MultiPayloadNoSpareBits { case c } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch(i64, i8) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch(i64 %0, i8 %1) {{.*}} { sil @multi_payload_no_spare_bits_switch : $(MultiPayloadNoSpareBits) -> () { entry(%u : $MultiPayloadNoSpareBits): // CHECK-64: switch i8 %1, label %[[UNREACHABLE:[0-9]+]] [ @@ -1466,7 +1466,7 @@ end: return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bits_switch_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}}) %0) {{.*}} { sil @multi_payload_no_spare_bits_switch_indirect : $(@inout MultiPayloadNoSpareBits) -> () { entry(%u : $*MultiPayloadNoSpareBits): // CHECK-64: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i64* @@ -1513,7 +1513,7 @@ end: return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_x(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_x(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[RES_0:%.*]] = insertvalue { i64, i8 } undef, i64 %0, 0 // CHECK-64: [[RES:%.*]] = insertvalue { i64, i8 } [[RES_0]], i8 0, 1 @@ -1525,7 +1525,7 @@ entry(%0 : $Builtin.Int64): return %u : $MultiPayloadNoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_x_indirect(i64, %T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_x_indirect(i64 %0, %T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %1 to i64* // CHECK-64: store i64 %0, i64* [[DATA_ADDR]] @@ -1543,7 +1543,7 @@ entry(%0 : $Builtin.Int64, %1 : $*MultiPayloadNoSpareBits): return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_y(i32) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_y(i32 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[ZEXT:%.*]] = zext i32 %0 to i64 // CHECK-64: [[RES_0:%.*]] = insertvalue { i64, i8 } undef, i64 [[ZEXT]], 0 @@ -1556,7 +1556,7 @@ entry(%0 : $Builtin.Int32): return %u : $MultiPayloadNoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_z(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_no_spare_bit_inject_z(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i63 // CHECK-64: [[ZEXT:%.*]] = zext i63 [[NATIVECC_TRUNC]] to i64 @@ -1580,7 +1580,7 @@ entry: return %u : $MultiPayloadNoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_a_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_no_spare_bit_inject_a_indirect(%T4enum23MultiPayloadNoSpareBitsO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadNoSpareBitsO* %0 to i64* // CHECK-64: store i64 0, i64* [[PAYLOAD_ADDR]] @@ -1625,7 +1625,7 @@ enum MultiPayloadOneSpareBit { case c } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_switch(i64, i8) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_switch(i64 %0, i8 %1) {{.*}} { sil @multi_payload_one_spare_bit_switch : $(MultiPayloadOneSpareBit) -> () { entry(%u : $MultiPayloadOneSpareBit): // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i8 %1 to i1 @@ -1766,7 +1766,7 @@ end: return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_x(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_x(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62 // CHECK-64: [[ZEXT:%.*]] = zext i62 [[NATIVECC_TRUNC]] to i64 @@ -1780,7 +1780,7 @@ entry(%0 : $Builtin.Int62): return %u : $MultiPayloadOneSpareBit } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_x_indirect(i64, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_x_indirect(i64 %0, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62 // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i62* @@ -1805,7 +1805,7 @@ entry(%0 : $Builtin.Int62, %1 : $*MultiPayloadOneSpareBit): return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_y(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_y(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i63 // CHECK-64: [[ZEXT:%.*]] = zext i63 [[NATIVECC_TRUNC]] to i64 @@ -1821,7 +1821,7 @@ entry(%0 : $Builtin.Int63): return %u : $MultiPayloadOneSpareBit } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_y_indirect(i64, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_y_indirect(i64 %0, %T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i63 // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %1 to i63* @@ -1849,7 +1849,7 @@ entry(%0 : $Builtin.Int63, %1 : $*MultiPayloadOneSpareBit): return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_z(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @multi_payload_one_spare_bit_inject_z(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i61 // CHECK-64: [[ZEXT:%.*]] = zext i61 [[NATIVECC_TRUNC]] to i64 @@ -1874,7 +1874,7 @@ entry: return %u : $MultiPayloadOneSpareBit } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_a_indirect(%T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_one_spare_bit_inject_a_indirect(%T4enum23MultiPayloadOneSpareBitO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum23MultiPayloadOneSpareBitO* %0 to i64* // -- 0x8000_0000_0000_0000 @@ -1923,7 +1923,7 @@ enum MultiPayloadTwoSpareBits { case c } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_switch(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_switch(i64 %0) {{.*}} { sil @multi_payload_two_spare_bits_switch : $(MultiPayloadTwoSpareBits) -> () { entry(%u : $MultiPayloadTwoSpareBits): // CHECK-64: [[TAG_LSHR:%.*]] = lshr i64 %0, 62 @@ -2008,7 +2008,7 @@ end: return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_x(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_x(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62 // CHECK-64: [[ZEXT:%.*]] = zext i62 [[NATIVECC_TRUNC]] to i64 @@ -2020,7 +2020,7 @@ entry(%0 : $Builtin.Int62): return %u : $MultiPayloadTwoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_x_indirect(i64, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_x_indirect(i64 %0, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i62 // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i62* @@ -2042,7 +2042,7 @@ entry(%0 : $Builtin.Int62, %1 : $*MultiPayloadTwoSpareBits): return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_y(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_y(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i60 // CHECK-64: [[ZEXT:%.*]] = zext i60 [[NATIVECC_TRUNC]] to i64 @@ -2056,7 +2056,7 @@ entry(%0 : $Builtin.Int60): return %u : $MultiPayloadTwoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_y_indirect(i64, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_y_indirect(i64 %0, %T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i60 // CHECK-64: [[DATA_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %1 to i60* @@ -2080,7 +2080,7 @@ entry(%0 : $Builtin.Int60, %1 : $*MultiPayloadTwoSpareBits): return %v : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_z(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc i64 @multi_payload_two_spare_bits_inject_z(i64 %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[NATIVECC_TRUNC:%.*]] = trunc i64 %0 to i61 // CHECK-64: [[ZEXT:%.*]] = zext i61 [[NATIVECC_TRUNC]] to i64 @@ -2105,7 +2105,7 @@ entry: return %u : $MultiPayloadTwoSpareBits } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_a_indirect(%T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_two_spare_bits_inject_a_indirect(%T4enum24MultiPayloadTwoSpareBitsO* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-64: entry: // CHECK-64: [[PAYLOAD_ADDR:%.*]] = bitcast %T4enum24MultiPayloadTwoSpareBitsO* %0 to i64* // -- 0xC000_0000_0000_0000 @@ -2153,7 +2153,7 @@ enum MultiPayloadClasses { case w } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_classes_switch(i64) {{.*}} { +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_classes_switch(i64 %0) {{.*}} { // CHECK-64: %1 = lshr i64 %0, 62 // CHECK-64: %2 = trunc i64 %1 to i8 // CHECK-64: %3 = and i8 %2, 3 @@ -2175,7 +2175,7 @@ enum MultiPayloadClasses { // CHECK-64: [[MASKED:%.*]] = and i64 %0, 4611686018427387903 // CHECK-64: inttoptr i64 [[MASKED]] to %T4enum1DC* -// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_classes_switch(i32) {{.*}} { +// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_classes_switch(i32 %0) {{.*}} { // CHECK-32: %1 = trunc i32 %0 to i8 // CHECK-32: %2 = and i8 %1, 3 // CHECK-32: switch i8 %2, label {{%.*}} [ @@ -2227,7 +2227,7 @@ enum MultiPayloadSpareBitAggregates { case z(S) } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_spare_bit_aggregate_switch(i64, i64) {{.*}} { +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_spare_bit_aggregate_switch(i64 %0, i64 %1) {{.*}} { // CHECK-64: [[T0:%.*]] = lshr i64 %0, 62 // CHECK-64: [[TAG_BYTE:%.*]] = trunc i64 [[T0]] to i8 // CHECK-64: [[TAG:%.*]] = and i8 [[TAG_BYTE]], 3 @@ -2311,7 +2311,7 @@ enum MultiPayloadNestedSpareBits { case B(MultiPayloadInnerSpareBits) } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_nested_spare_bits_switch(%T4enum27MultiPayloadNestedSpareBitsO* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_nested_spare_bits_switch(%T4enum27MultiPayloadNestedSpareBitsO* noalias nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-64: entry: // CHECK-64: %1 = bitcast %T4enum27MultiPayloadNestedSpareBitsO* %0 to [[WORD]]* // CHECK-64: %2 = load [[WORD]], [[WORD]]* %1 @@ -2363,15 +2363,15 @@ enum MultiPayloadClassGeneric { case B(T) } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64, i8 } @multi_payload_class_generic_no_spare_bits(i64, i64, i8, %swift.type* %T) -// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32, i8 } @multi_payload_class_generic_no_spare_bits(i32, i32, i8, %swift.type* %T) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64, i8 } @multi_payload_class_generic_no_spare_bits(i64 %0, i64 %1, i8 %2, %swift.type* %T) +// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32, i8 } @multi_payload_class_generic_no_spare_bits(i32 %0, i32 %1, i8 %2, %swift.type* %T) sil @multi_payload_class_generic_no_spare_bits : $@convention(thin) (@owned MultiPayloadClassGeneric) -> MultiPayloadClassGeneric { entry(%e : $MultiPayloadClassGeneric): return %e : $MultiPayloadClassGeneric } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64, i8 } @multi_payload_class_instance_no_spare_bits(i64, i64, i8) -// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32, i8 } @multi_payload_class_instance_no_spare_bits(i32, i32, i8) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i64, i8 } @multi_payload_class_instance_no_spare_bits(i64 %0, i64 %1, i8 %2) +// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i32, i8 } @multi_payload_class_instance_no_spare_bits(i32 %0, i32 %1, i8 %2) sil @multi_payload_class_instance_no_spare_bits : $@convention(thin) (@owned MultiPayloadClassGeneric) -> MultiPayloadClassGeneric { entry(%e : $MultiPayloadClassGeneric): return %e : $MultiPayloadClassGeneric @@ -2382,7 +2382,7 @@ enum MultiPayloadAddressOnlyFixed { case Y(Builtin.Int32) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_address_only_destroy(%T4enum28MultiPayloadAddressOnlyFixedO* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_address_only_destroy(%T4enum28MultiPayloadAddressOnlyFixedO* noalias nocapture dereferenceable({{.*}}) %0) sil @multi_payload_address_only_destroy : $@convention(thin) (@in MultiPayloadAddressOnlyFixed) -> () { entry(%m : $*MultiPayloadAddressOnlyFixed): destroy_addr %m : $*MultiPayloadAddressOnlyFixed @@ -2402,7 +2402,7 @@ enum MultiPayloadAddressOnlySpareBits { case Y(AddressOnlySpareBitsPayload) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_address_only_spare_bits(%T4enum32MultiPayloadAddressOnlySpareBitsO* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @multi_payload_address_only_spare_bits(%T4enum32MultiPayloadAddressOnlySpareBitsO* noalias nocapture dereferenceable({{.*}}) %0) sil @multi_payload_address_only_spare_bits : $@convention(thin) (@in MultiPayloadAddressOnlySpareBits) -> () { entry(%m : $*MultiPayloadAddressOnlySpareBits): destroy_addr %m : $*MultiPayloadAddressOnlySpareBits @@ -2431,7 +2431,7 @@ typealias AllConcreteTestEnums = ( sil_global @x : $AllConcreteTestEnums -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_singleton_switch_indirect([[DYNAMIC_SINGLETON]]* noalias nocapture, %swift.type* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_singleton_switch_indirect([[DYNAMIC_SINGLETON]]* noalias nocapture %0, %swift.type* %T) {{.*}} { // CHECK: bitcast [[DYNAMIC_SINGLETON]]* %0 to %swift.opaque* // CHECK: ret void // CHECK: } @@ -2455,7 +2455,7 @@ entry(%0 : $DynamicSingleton<()>): %v = tuple () return %v : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_singleton_instance_arg_2(i8) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_singleton_instance_arg_2(i8 %0) sil @dynamic_singleton_instance_arg_2 : $(DynamicSingleton) -> () { entry(%0 : $DynamicSingleton): %v = tuple () @@ -2464,11 +2464,11 @@ entry(%0 : $DynamicSingleton): // Check that payloads get properly masked in nested single-payload enums. // rdar://problem/18841262 -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @optional_optional_class_protocol(i64, i64) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @optional_optional_class_protocol(i64 %0, i64 %1) // CHECK-objc-64-simulator-false: icmp eq i64 %0, 2 // CHECK-objc-64-simulator-true: icmp eq i64 %0, 1 // CHECK-native-64: icmp eq i64 %0, 1 -// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @optional_optional_class_protocol(i32, i32) +// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @optional_optional_class_protocol(i32 %0, i32 %1) // CHECK-32: icmp eq i32 %0, 1 enum Optionable { case some(T), none @@ -2508,7 +2508,7 @@ entry: return %t : $(Optionable, Optionable>) } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @empty_payload_enum_in_enum(i32) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @empty_payload_enum_in_enum(i32 %0) sil @empty_payload_enum_in_enum : $@convention(thin) (Int32) -> Optional<(Optional<()>, Int32)> { entry(%x : $Int32): %a = tuple () @@ -2538,7 +2538,7 @@ struct StructWithWeakVar { weak var delegate: delegateProtocol? } -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @weak_optional(%T4enum17StructWithWeakVarVSg* noalias nocapture dereferenceable({{.*}})) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @weak_optional(%T4enum17StructWithWeakVarVSg* noalias nocapture dereferenceable({{.*}}) %0) sil @weak_optional : $@convention(thin) (@in StructWithWeakVar?) -> () { entry(%x : $*StructWithWeakVar?): // CHECK-64: icmp eq [[WORD]] {{%.*}}, 0 @@ -2653,14 +2653,14 @@ entry(%x : $*MyOptional): } // -- Fill function for dynamic singleton. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s4enum16DynamicSingletonOMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s4enum16DynamicSingletonOMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: [[T:%T]] = load %swift.type*, %swift.type** [[T0]], // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2, [[WORD]] {{4|8}}) // CHECK-NEXT: ret %swift.type* [[METADATA]] // CHECK-LABEL: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s4enum16DynamicSingletonOMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[WORD]] 319, %swift.type* [[T]]) // CHECK: [[T_CHECKED:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK: [[T_STATUS:%.*]] = extractvalue %swift.metadata_response [[T0]], 1 @@ -2688,7 +2688,7 @@ entry(%x : $*MyOptional): // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc %swift.metadata_response @"$s4enum20DynamicSinglePayloadOMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[WORD]] 319, %swift.type* [[T]]) // CHECK: [[T_CHECKED:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK: [[T_STATUS:%.*]] = extractvalue %swift.metadata_response [[T0]], 1 diff --git a/test/IRGen/enum_32_bit.sil b/test/IRGen/enum_32_bit.sil index 6353c2bbb8df7..0661027e26ca4 100644 --- a/test/IRGen/enum_32_bit.sil +++ b/test/IRGen/enum_32_bit.sil @@ -37,19 +37,19 @@ enum Bas { case Z } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @foo(i32) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @foo(i32 %0) sil @foo : $@convention(thin) (@owned Foo) -> () { entry(%0 : $Foo): return undef : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bar(i32) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bar(i32 %0) sil @bar : $@convention(thin) (@owned Bar) -> () { entry(%0 : $Bar): return undef : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bas(i32) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bas(i32 %0) sil @bas : $@convention(thin) (@owned Bas) -> () { entry(%0 : $Bas): return undef : $() diff --git a/test/IRGen/enum_derived.swift b/test/IRGen/enum_derived.swift index e5b5f59c3b4b4..4f768efd86dbc 100644 --- a/test/IRGen/enum_derived.swift +++ b/test/IRGen/enum_derived.swift @@ -17,16 +17,16 @@ enum E { // Check if the == comparison can be compiled to a simple icmp instruction. -// CHECK-NORMAL-LABEL:define hidden swiftcc i1 @"$s12enum_derived1EO02__b1_A7_equalsySbAC_ACtFZ"(i8, i8) -// CHECK-TESTABLE-LABEL:define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s12enum_derived1EO02__b1_A7_equalsySbAC_ACtFZ"(i8, i8) +// CHECK-NORMAL-LABEL:define hidden swiftcc i1 @"$s12enum_derived1EO02__b1_A7_equalsySbAC_ACtFZ"(i8 %0, i8 %1) +// CHECK-TESTABLE-LABEL:define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s12enum_derived1EO02__b1_A7_equalsySbAC_ACtFZ"(i8 %0, i8 %1) // CHECK: %2 = icmp eq i8 %0, %1 // CHECK: ret i1 %2 // Check for the presence of the hashValue getter, calling Hasher.init() and // Hasher.finalize(). -// CHECK-NORMAL-LABEL:define hidden swiftcc i{{.*}} @"$s12enum_derived1EO9hashValueSivg"(i8) -// CHECK-TESTABLE-LABEL:define{{( dllexport)?}}{{( protected)?}} swiftcc i{{.*}} @"$s12enum_derived1EO9hashValueSivg"(i8) +// CHECK-NORMAL-LABEL:define hidden swiftcc i{{.*}} @"$s12enum_derived1EO9hashValueSivg"(i8 %0) +// CHECK-TESTABLE-LABEL:define{{( dllexport)?}}{{( protected)?}} swiftcc i{{.*}} @"$s12enum_derived1EO9hashValueSivg"(i8 %0) // CHECK: call swiftcc void @"$ss6HasherV5_seedABSi_tcfC"(%Ts6HasherV* {{.*}}) // CHECK: call swiftcc i{{[0-9]+}} @"$ss6HasherV9_finalizeSiyF"(%Ts6HasherV* {{.*}}) // CHECK: ret i{{[0-9]+}} %{{[0-9]+}} @@ -47,8 +47,8 @@ extension def_enum.TrafficLight : Error {} extension def_enum.Term : Error {} -// CHECK-NORMAL-LABEL: define hidden {{.*}}i64 @"$s12enum_derived7PhantomO8rawValues5Int64Vvg"(i8, %swift.type* nocapture readnone %T) local_unnamed_addr -// CHECK-TESTABLE-LABEL: define{{( dllexport)?}}{{( protected)?}} {{.*}}i64 @"$s12enum_derived7PhantomO8rawValues5Int64Vvg"(i8, %swift.type* nocapture readnone %T) +// CHECK-NORMAL-LABEL: define hidden {{.*}}i64 @"$s12enum_derived7PhantomO8rawValues5Int64Vvg"(i8 %0, %swift.type* nocapture readnone %T) local_unnamed_addr +// CHECK-TESTABLE-LABEL: define{{( dllexport)?}}{{( protected)?}} {{.*}}i64 @"$s12enum_derived7PhantomO8rawValues5Int64Vvg"(i8 %0, %swift.type* nocapture readnone %T) enum Phantom : Int64 { case Up diff --git a/test/IRGen/enum_dynamic_multi_payload.sil b/test/IRGen/enum_dynamic_multi_payload.sil index e45eb4b42e698..ecd594c217a26 100644 --- a/test/IRGen/enum_dynamic_multi_payload.sil +++ b/test/IRGen/enum_dynamic_multi_payload.sil @@ -22,15 +22,15 @@ sil_vtable C {} // -- The runtime doesn't track spare bits, so fixed instances of the dynamic // type can't use them. -// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @fixed_instances_dont_use_spare_bits(i64, i8) -// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i8 } @fixed_instances_dont_use_spare_bits(i32, i8) +// CHECK-64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i8 } @fixed_instances_dont_use_spare_bits(i64 %0, i8 %1) +// CHECK-32-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i8 } @fixed_instances_dont_use_spare_bits(i32 %0, i8 %1) sil @fixed_instances_dont_use_spare_bits : $@convention(thin) (@owned Either) -> @owned Either { entry(%e : $Either): return %e : $Either } // -- Handle case where all of the payloads become empty. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @empty_instance(i8) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @empty_instance(i8 %0) {{.*}} { sil @empty_instance : $@convention(thin) (Either<(), ()>) -> () { // CHECK-NEXT: entry: entry(%e : $Either<(), ()>): @@ -80,7 +80,7 @@ next(%z : $Builtin.Int8): return undef : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @empty_instance2(i8) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @empty_instance2(i8 %0) {{.*}} { sil @empty_instance2 : $@convention(thin) (EitherOr<(), ()>) -> () { // CHECK-NEXT: entry: entry(%e : $EitherOr<(), ()>): @@ -264,7 +264,7 @@ entry: } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_inject -// CHECK: ([[EITHER_OR:%T26enum_dynamic_multi_payload8EitherOrO.*]]* noalias nocapture sret, %swift.type* %T) +// CHECK: ([[EITHER_OR:%T26enum_dynamic_multi_payload8EitherOrO.*]]* noalias nocapture sret %0, %swift.type* %T) sil @dynamic_inject : $@convention(thin) () -> @out EitherOr { entry(%e : $*EitherOr): // CHECK: call void @swift_storeEnumTagMultiPayload(%swift.opaque* {{%.*}}, %swift.type* [[TYPE:%.*]], i32 0) @@ -280,7 +280,7 @@ entry(%e : $*EitherOr): } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_project -// CHECK: ([[EITHER_OR]]* noalias nocapture sret, %swift.type* %T) +// CHECK: ([[EITHER_OR]]* noalias nocapture sret %0, %swift.type* %T) sil @dynamic_project : $@convention(thin) () -> @out EitherOr { entry(%e : $*EitherOr): // CHECK: bitcast [[EITHER_OR]]* %0 to %swift.opaque* @@ -292,7 +292,7 @@ entry(%e : $*EitherOr): } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_switch -// CHECK: ([[EITHER_OR]]* noalias nocapture sret, %swift.type* %T) +// CHECK: ([[EITHER_OR]]* noalias nocapture sret %0, %swift.type* %T) sil @dynamic_switch : $@convention(thin) () -> @out EitherOr { entry(%e : $*EitherOr): // CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload @@ -333,7 +333,7 @@ next(%x : $Builtin.Int8): } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_value_semantics -// CHECK: ([[EITHER_OR]]* noalias nocapture sret, [[EITHER_OR]]* noalias nocapture, %swift.type* %T) +// CHECK: ([[EITHER_OR]]* noalias nocapture sret %0, [[EITHER_OR]]* noalias nocapture %1, %swift.type* %T) sil @dynamic_value_semantics : $@convention(thin) (@in EitherOr) -> @out EitherOr { entry(%a : $*EitherOr, %b : $*EitherOr): // CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload @@ -367,7 +367,7 @@ entry(%a : $*EitherOr, %b : $*EitherOr): } // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_value_semantics2 -// CHECK: ([[EITHER_OR:%T26enum_dynamic_multi_payload8EitherOrO.*]]* noalias nocapture sret, [[EITHER_OR]]* noalias nocapture, %swift.type* %T) +// CHECK: ([[EITHER_OR:%T26enum_dynamic_multi_payload8EitherOrO.*]]* noalias nocapture sret %0, [[EITHER_OR]]* noalias nocapture %1, %swift.type* %T) sil @dynamic_value_semantics2 : $@convention(thin) (@in EitherOr) -> @out EitherOr { entry(%a : $*EitherOr, %b : $*EitherOr): // CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload @@ -417,11 +417,11 @@ entry(%a : $*EitherOr, %b : $*EitherOr): return undef : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s26enum_dynamic_multi_payload8EitherOrOMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s26enum_dynamic_multi_payload8EitherOrOMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata // CHECK: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s26enum_dynamic_multi_payload8EitherOrOMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // CHECK: [[BUF:%.*]] = alloca [2 x i8**] // CHECK: [[BUF0:%.*]] = getelementptr {{.*}} [[BUF]], i32 0, i32 0 diff --git a/test/IRGen/enum_function.sil b/test/IRGen/enum_function.sil index b4e767bce24fd..78f3967cce8aa 100644 --- a/test/IRGen/enum_function.sil +++ b/test/IRGen/enum_function.sil @@ -12,8 +12,8 @@ bb0: return %0 : $() } -// CHECK-64: define hidden swiftcc void @test1([[WORD:i64]], [[WORD]]) -// CHECK-32: define hidden swiftcc void @test1([[WORD:i32]], [[WORD]]) +// CHECK-64: define hidden swiftcc void @test1([[WORD:i64]] %0, [[WORD]] %1) +// CHECK-32: define hidden swiftcc void @test1([[WORD:i32]] %0, [[WORD]] %1) sil hidden @test1 : $@convention(thin) (@owned Optional<() -> ()>) -> () { bb0(%0 : $Optional<() -> ()>): // CHECK: call void @"$sIey_SgWOy" diff --git a/test/IRGen/enum_objc.sil b/test/IRGen/enum_objc.sil index 9f537dbf126a2..b0834f27b4111 100644 --- a/test/IRGen/enum_objc.sil +++ b/test/IRGen/enum_objc.sil @@ -29,7 +29,7 @@ enum SinglePayloadObjCProtocol { case y, z, w } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i64, i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i64 %0, i64 %1) {{.*}} { // CHECK-64: switch i64 %0, label {{%.*}} [ // CHECK-64: i64 0, label {{%.*}} // CHECK-64-simulator-false: i64 2, label {{%.*}} @@ -41,7 +41,7 @@ enum SinglePayloadObjCProtocol { // CHECK-64: inttoptr i64 %0 to %objc_object* // CHECK-64: inttoptr i64 %1 to i8** -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i32, i32) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_class_protocol_switch(i32 %0, i32 %1) {{.*}} { // CHECK-32: switch i32 %0, label {{%.*}} [ // CHECK-32: i32 0, label {{%.*}} // CHECK-32: i32 1, label {{%.*}} @@ -68,7 +68,7 @@ end: return undef : $() } -// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_objc_protocol_switch(i64) {{.*}} { +// CHECK-64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_objc_protocol_switch(i64 %0) {{.*}} { // CHECK-64: switch i64 %0, label {{%.*}} // CHECK-64: i64 0, label {{%.*}} // CHECK-64-simulator-false: i64 2, label {{%.*}} @@ -78,7 +78,7 @@ end: // CHECK-64: ] // CHECK-64: inttoptr i64 %0 to %objc_object* -// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_objc_protocol_switch(i32) {{.*}} { +// CHECK-32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_objc_protocol_switch(i32 %0) {{.*}} { // CHECK-32: switch i32 %0, label {{%.*}} // CHECK-32: i32 0, label {{%.*}} // CHECK-32: i32 1, label {{%.*}} @@ -109,7 +109,7 @@ struct StructWithWeakVar { weak var delegate: delegateProtocol? } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @weak_optional(%T9enum_objc17StructWithWeakVarVSg* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @weak_optional(%T9enum_objc17StructWithWeakVarVSg* noalias nocapture dereferenceable({{.*}}) %0) sil @weak_optional : $@convention(thin) (@in StructWithWeakVar?) -> () { entry(%x : $*StructWithWeakVar?): // CHECK: icmp eq [[WORD:i32|i64]] {{%.*}}, 0 diff --git a/test/IRGen/enum_resilience.swift b/test/IRGen/enum_resilience.swift index 4d23d811bf323..909a1b31a2fbe 100644 --- a/test/IRGen/enum_resilience.swift +++ b/test/IRGen/enum_resilience.swift @@ -88,7 +88,7 @@ enum InternalEither { case Right(ReferenceFast) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25functionWithResilientEnumy010resilient_A06MediumOAEF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25functionWithResilientEnumy010resilient_A06MediumOAEF"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1) public func functionWithResilientEnum(_ m: Medium) -> Medium { // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0) @@ -106,7 +106,7 @@ public func functionWithResilientEnum(_ m: Medium) -> Medium { return m } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience33functionWithIndirectResilientEnumy010resilient_A00E8ApproachOAEF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience33functionWithIndirectResilientEnumy010resilient_A00E8ApproachOAEF"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1) public func functionWithIndirectResilientEnum(_ ia: IndirectApproach) -> IndirectApproach { // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum16IndirectApproachOMa"([[INT]] 0) @@ -190,7 +190,7 @@ public func constructResilientEnumPayload(_ s: Size) -> Medium { return Medium.Postcard(s) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i32|i64}} @"$s15enum_resilience19resilientSwitchTestySi0c1_A06MediumOF"(%swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i32|i64}} @"$s15enum_resilience19resilientSwitchTestySi0c1_A06MediumOF"(%swift.opaque* noalias nocapture %0) // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8*** @@ -263,7 +263,7 @@ public func resilientSwitchTest(_ m: Medium) -> Int { public func reabstraction(_ f: (Medium) -> T) {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOXEF"(i8*, %swift.opaque*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOXEF"(i8* %0, %swift.opaque* %1) public func resilientEnumPartialApply(_ f: (Medium) -> Int) { // CHECK: [[STACKALLOC:%.*]] = alloca i8 @@ -274,7 +274,7 @@ public func resilientEnumPartialApply(_ f: (Medium) -> Int) { // CHECK: ret void } -// CHECK-LABEL: define internal swiftcc void @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA"(%TSi* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA"(%TSi* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.refcounted* swiftself %2) // Enums with resilient payloads from a different resilience domain @@ -320,7 +320,7 @@ public func getResilientEnumType() -> Any.Type { // from metadata -- make sure we can do that extension ResilientMultiPayloadGenericEnum { -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s14resilient_enum32ResilientMultiPayloadGenericEnumO0B11_resilienceE16getTypeParameterxmyF"(%swift.type* %"ResilientMultiPayloadGenericEnum", %swift.opaque* noalias nocapture swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s14resilient_enum32ResilientMultiPayloadGenericEnumO0B11_resilienceE16getTypeParameterxmyF"(%swift.type* %"ResilientMultiPayloadGenericEnum", %swift.opaque* noalias nocapture swiftself %0) // CHECK: [[METADATA:%.*]] = bitcast %swift.type* %"ResilientMultiPayloadGenericEnum" to %swift.type** // CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[METADATA]], [[INT]] 2 // CHECK-NEXT: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]] @@ -329,7 +329,7 @@ extension ResilientMultiPayloadGenericEnum { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience39constructExhaustiveWithResilientMembers010resilient_A011SimpleShapeOyF"(%T14resilient_enum11SimpleShapeO* noalias nocapture sret) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience39constructExhaustiveWithResilientMembers010resilient_A011SimpleShapeOyF"(%T14resilient_enum11SimpleShapeO* noalias nocapture sret %0) // CHECK: [[BUFFER:%.*]] = bitcast %T14resilient_enum11SimpleShapeO* %0 to %swift.opaque* // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct4SizeVMa"([[INT]] 0) // CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 @@ -348,7 +348,7 @@ public func constructFullyFixed() -> FullyFixedLayout { return .noPayload } -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: [[TUPLE_LAYOUT:%.*]] = alloca %swift.full_type_layout // CHECK: [[SIZE_RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct4SizeVMa"([[INT]] 319) // CHECK-NEXT: [[SIZE_METADATA:%.*]] = extractvalue %swift.metadata_response [[SIZE_RESPONSE]], 0 diff --git a/test/IRGen/enum_value_semantics.sil b/test/IRGen/enum_value_semantics.sil index ff23670af0d11..827650cdf9200 100644 --- a/test/IRGen/enum_value_semantics.sil +++ b/test/IRGen/enum_value_semantics.sil @@ -182,7 +182,7 @@ bb0(%0 : $SinglePayloadNontrivial): return %v : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_nontrivial_copy_destroy(i64) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @single_payload_nontrivial_copy_destroy(i64 %0) // CHECK: call void @"$s20enum_value_semantics23SinglePayloadNontrivialOWOy" // CHECK-NEXT: call swiftcc void @single_payload_nontrivial_user // CHECK-NEXT: call void @"$s20enum_value_semantics23SinglePayloadNontrivialOWOe" diff --git a/test/IRGen/errors.sil b/test/IRGen/errors.sil index bbbcceb5ab08e..05c64e2d8e5fd 100644 --- a/test/IRGen/errors.sil +++ b/test/IRGen/errors.sil @@ -15,13 +15,13 @@ entry: unreachable } -// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error**) {{.*}} { -// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { +// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** %1) {{.*}} { +// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { sil @does_throw : $@convention(thin) () -> @error Error { // CHECK: [[T0:%.*]] = call swiftcc %swift.error* @create_error() %0 = function_ref @create_error : $@convention(thin) () -> @owned Error @@ -36,13 +36,13 @@ sil @does_throw : $@convention(thin) () -> @error Error { throw %1 : $Error } -// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error**) {{.*}} { -// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { -// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself, %swift.error** swifterror) {{.*}} { +// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** %1) {{.*}} { +// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { +// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} { sil @doesnt_throw : $@convention(thin) () -> @error Error { // We don't have to do anything here because the caller always // zeroes the error slot before a call. @@ -54,8 +54,8 @@ sil @doesnt_throw : $@convention(thin) () -> @error Error { sil @try_apply_helper : $@convention(thin) (@owned AnyObject) -> (@owned AnyObject, @error Error) -// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%objc_object*) -// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%swift.refcounted*) +// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%objc_object* %0) +// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%swift.refcounted* %0) sil @try_apply : $@convention(thin) (@owned AnyObject) -> () { entry(%0 : $AnyObject): // CHECK-i386: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]]%swift.error*, align @@ -115,9 +115,9 @@ bb0(%0 : $Error): // rdar://21084084 - Partial application of throwing functions. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_single(%T6errors1AC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_single(%T6errors1AC* %0) // CHECK: insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*, %swift.error**)* @"$s27partial_apply_single_helperTA" to i8*), %swift.refcounted* undef }, -// CHECK: define internal swiftcc void @"$s27partial_apply_single_helperTA"(%swift.refcounted* swiftself, %swift.error** noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}})) +// CHECK: define internal swiftcc void @"$s27partial_apply_single_helperTA"(%swift.refcounted* swiftself %0, %swift.error** noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) %1) // CHECK: [[T0:%.*]] = bitcast %swift.refcounted* {{%.*}} to %T6errors1AC* // CHECK-NEXT: tail call swiftcc void @partial_apply_single_helper(%T6errors1AC* [[T0]], %swift.refcounted* swiftself undef, %swift.error** noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}){{( )?}}{{%.*}}) // CHECK-NEXT: ret void diff --git a/test/IRGen/exact_self_class_metadata_peephole.swift b/test/IRGen/exact_self_class_metadata_peephole.swift index 7dbbdf970df74..b700add5f8864 100644 --- a/test/IRGen/exact_self_class_metadata_peephole.swift +++ b/test/IRGen/exact_self_class_metadata_peephole.swift @@ -66,7 +66,7 @@ final private class FinalPrivateNonfinalSubclass: PrivateNonfinal.self) - // CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}}FinalPrivateNonfinalSubclass + // CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}}FinalPrivateNonfinalSubclass // CHECK: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]]) useMetadata(FinalPrivateNonfinalSubclass.self) } @@ -85,7 +85,7 @@ final private class PrivateFinal { // CHECK: [[TYPE:%.*]] = load {{.*}} [[TYPE_GEP]] // CHECK: call {{.*}} @useMetadata(%swift.type* [[TYPE]], %swift.type* [[TYPE]]) useMetadata(PrivateFinal.self) - // CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}}PrivateFinal + // CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}}PrivateFinal // CHECK: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]]) useMetadata(PrivateFinal.self) } @@ -102,3 +102,4 @@ public func useStuff(_: T, _: U, _: V) { PrivateFinal().butts() } + diff --git a/test/IRGen/existential_metatypes.sil b/test/IRGen/existential_metatypes.sil index d2801dafcd834..be004f33a0f0e 100644 --- a/test/IRGen/existential_metatypes.sil +++ b/test/IRGen/existential_metatypes.sil @@ -89,7 +89,7 @@ bb0(%0 : $@thick Kindable.Type): return %2 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test1(i64, i64) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test1(i64 %0, i64 %1) sil @test1 : $@convention(thin) (Optional<@thick Kindable.Type>) -> () { bb0(%0 : $Optional<@thick Kindable.Type>): // CHECK: [[TYPE:%.*]] = inttoptr i64 %0 to %swift.type* diff --git a/test/IRGen/existentials.sil b/test/IRGen/existentials.sil index d5ce86b9491aa..0cb3847b7f23f 100644 --- a/test/IRGen/existentials.sil +++ b/test/IRGen/existentials.sil @@ -16,7 +16,7 @@ struct BitwiseTakable { protocol CP: class {} -// CHECK-DAG: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.refcounted*, i8** } @class_existential_unowned(%swift.refcounted*, i8**) {{.*}} { +// CHECK-DAG: define{{( dllexport)?}}{{( protected)?}} swiftcc { %swift.refcounted*, i8** } @class_existential_unowned(%swift.refcounted* %0, i8** %1) {{.*}} { sil @class_existential_unowned : $@convention(thin) (@owned CP) -> @owned CP { entry(%s : $CP): %u = ref_to_unowned %s : $CP to $@sil_unowned CP @@ -46,7 +46,7 @@ entry(%s : $CP): return %z : $CP } -// CHECK-DAG: define{{( dllexport)?}}{{( protected)?}} swiftcc void @class_existential_weak({ %swift.weak, i8** }* noalias nocapture sret, i64, i64) +// CHECK-DAG: define{{( dllexport)?}}{{( protected)?}} swiftcc void @class_existential_weak({ %swift.weak, i8** }* noalias nocapture sret %0, i64 %1, i64 %2) sil @class_existential_weak : $@convention(thin) (@owned CP?) -> @out @sil_weak CP? { entry(%w : $*@sil_weak CP?, %a : $CP?): // CHECK: [[V:%.*]] = alloca { %swift.weak, i8** } diff --git a/test/IRGen/existentials_objc.sil b/test/IRGen/existentials_objc.sil index 0f8e3359a38b0..4b1994d1a3b82 100644 --- a/test/IRGen/existentials_objc.sil +++ b/test/IRGen/existentials_objc.sil @@ -22,7 +22,7 @@ bb0(%0 : $*Any, %1 : $T): return %3 : $() } -// CHECK-DAG: define{{( protected)?}} swiftcc void @init_opaque_existential([[ANY:%Any]]* noalias nocapture sret, [[GIZMO:%.*]]*, [[TYPE:%.*]]* %T) {{.*}} { +// CHECK-DAG: define{{( protected)?}} swiftcc void @init_opaque_existential([[ANY:%Any]]* noalias nocapture sret %0, [[GIZMO:%.*]]* %1, [[TYPE:%.*]]* %T) {{.*}} { // CHECK: [[T0:%.*]] = getelementptr inbounds [[ANY]], [[ANY]]* %0, i32 0, i32 1 // CHECK-NEXT: store [[TYPE]]* %T, [[TYPE]]** [[T0]], align 8 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[ANY]], [[ANY]]* %0, i32 0, i32 0 @@ -38,11 +38,11 @@ bb0(%0 : $*Any, %1 : $*Any): return %3 : $() } -// CHECK-DAG: define{{( protected)?}} swiftcc void @take_opaque_existential([[ANY:%Any]]* noalias nocapture sret, %Any* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-DAG: define{{( protected)?}} swiftcc void @take_opaque_existential([[ANY:%Any]]* noalias nocapture sret %0, %Any* noalias nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK: call %Any* @"$sypWOb"(%Any* %1, %Any* %0) // CHECK-NEXT: ret void -// CHECK-DAG: define linkonce_odr hidden %Any* @"$sypWOb"(%Any*, %Any*) +// CHECK-DAG: define linkonce_odr hidden %Any* @"$sypWOb"(%Any* %0, %Any* %1) // CHECK: %2 = bitcast %Any* %1 to i8* // CHECK-NEXT: %3 = bitcast %Any* %0 to i8* // CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %2, i8* align 8 %3, i64 32, i1 false) @@ -52,7 +52,7 @@ bb0(%0 : $*Any, %1 : $*Any): @objc protocol OP {} @objc protocol OP2: OP {} -// CHECK-DAG: define{{( protected)?}} swiftcc %objc_object* @init_existential_objc_to_objc(%objc_object*) {{.*}} { +// CHECK-DAG: define{{( protected)?}} swiftcc %objc_object* @init_existential_objc_to_objc(%objc_object* %0) {{.*}} { // CHECK: ret %objc_object* %0 sil @init_existential_objc_to_objc : $@convention(thin) (@owned OP2) -> @owned OP { entry(%o : $OP2): @@ -62,7 +62,7 @@ entry(%o : $OP2): protocol CP: class {} -// CHECK-DAG: define{{( protected)?}} swiftcc { %objc_object*, i8** } @class_existential_unowned(%objc_object*, i8**) {{.*}} { +// CHECK-DAG: define{{( protected)?}} swiftcc { %objc_object*, i8** } @class_existential_unowned(%objc_object* %0, i8** %1) {{.*}} { sil @class_existential_unowned : $@convention(thin) (@owned CP) -> @owned CP { entry(%s : $CP): %u1 = alloc_stack $@sil_unowned CP @@ -100,7 +100,7 @@ entry(%s : $CP): return %z : $CP } -// CHECK-DAG: define{{( protected)?}} swiftcc void @class_existential_weak({ %swift.weak, i8** }* noalias nocapture sret, i64, i64) +// CHECK-DAG: define{{( protected)?}} swiftcc void @class_existential_weak({ %swift.weak, i8** }* noalias nocapture sret %0, i64 %1, i64 %2) sil @class_existential_weak : $@convention(thin) (@owned CP?) -> @out @sil_weak CP? { entry(%w : $*@sil_weak CP?, %a : $CP?): // CHECK: [[V:%.*]] = alloca { %swift.weak, i8** } @@ -158,7 +158,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?): @objc optional func funcA() } -// CHECK: define swiftcc void @useObjcProtocol(%objc_object* swiftself) +// CHECK: define swiftcc void @useObjcProtocol(%objc_object* swiftself %0) // CHECK: entry: // CHECK: load i8*, i8** @"\01L_selector(funcA)" // CHECK: load i8*, i8** @"\01L_selector(respondsToSelector:)" diff --git a/test/IRGen/existentials_opaque_boxed.sil b/test/IRGen/existentials_opaque_boxed.sil index 61a5997c0c984..14068795ed508 100644 --- a/test/IRGen/existentials_opaque_boxed.sil +++ b/test/IRGen/existentials_opaque_boxed.sil @@ -47,7 +47,7 @@ entry(%0 : $*T): return %t : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_allocate_boxed_opaque_existential_1(%__opaque_existential_type_1*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_allocate_boxed_opaque_existential_1(%__opaque_existential_type_1* %0) // CHECK: [[METATYPE_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1 // CHECK: [[METATYPE:%.*]] = load %swift.type*, %swift.type** [[METATYPE_ADDR]] // CHECK: [[CAST:%.*]] = bitcast %swift.type* [[METATYPE]] @@ -149,7 +149,7 @@ entry: return %t : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_deallocate_boxed_opaque_existential_1(%__opaque_existential_type_1*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_deallocate_boxed_opaque_existential_1(%__opaque_existential_type_1* %0) // CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1 // CHECK: [[META:%.*]] = load %swift.type*, %swift.type** [[META_ADDR]] // CHECK: [[CAST:%.*]] = bitcast %swift.type* [[META]] to i8*** @@ -204,7 +204,7 @@ bb0(%0 : $*Existential): return %t : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1*, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %swift.type* %1) // CHECK: [[CAST:%.*]] = bitcast %swift.type* %1 to i8*** // CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1 // CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]] @@ -251,7 +251,7 @@ bb0(%0 : $*Existential): return %t : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_mutable_project_boxed_opaque_existential_1(%__opaque_existential_type_1*, %swift.type*) +// CHECK: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_mutable_project_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %swift.type* %1) // CHECK: [[CAST:%.*]] = bitcast %swift.type* %1 to i8*** // CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1 // CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]] @@ -297,7 +297,7 @@ bb0(%0 : $*OtherExistential): return %t : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_destroy_boxed_opaque_existential_1(%__opaque_existential_type_1*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_destroy_boxed_opaque_existential_1(%__opaque_existential_type_1* %0) // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1 // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]] // CHECK: [[BUFFER_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 0 @@ -353,7 +353,7 @@ bb0(%0 : $*OtherExistential): return %t : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_assign_boxed_opaque_existential_1(%__opaque_existential_type_1*, %__opaque_existential_type_1*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_assign_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %__opaque_existential_type_1* %1) // CHECK: [[TMPBUFFER:%.*]] = alloca [{{(24|12)}} x i8] // CHECK: [[SELFASSIGN:%.*]] = icmp eq %__opaque_existential_type_1* %0, %1 // CHECK: br i1 [[SELFASSIGN]], label %done, label %cont @@ -524,7 +524,7 @@ bb0(%0 : $*OtherExistential): return %t : $() } -// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOb"(%T25existentials_opaque_boxed11ExistentialP*, %T25existentials_opaque_boxed11ExistentialP*) +// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOb"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* %1) // CHECK: %2 = bitcast %T25existentials_opaque_boxed11ExistentialP* %1 to i8* // CHECK: %3 = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to i8* // CHECK: call void @llvm.memcpy.p0i8.p0i8.{{(i64|i32)}}(i8* align {{(8|4)}} %2, i8* align {{(8|4)}} %3, {{(i64 40|i32 20)}}, i1 false) @@ -556,7 +556,7 @@ bb0(%0 : $*OtherExistential): // CHECK: [[LOCAL:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP // CHECK: call %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOc"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* [[LOCAL]]) // CHECK: ret void -// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOc"(%T25existentials_opaque_boxed11ExistentialP*, %T25existentials_opaque_boxed11ExistentialP*) +// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOc"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* %1) // CHECK: [[TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 1 // CHECK: [[ARG_TYPE:%.*]] = load %swift.type*, %swift.type** [[TYPE_ADDR]] // CHECK: [[LOCAL_TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %1, i32 0, i32 1 diff --git a/test/IRGen/fixed_layout_class.swift b/test/IRGen/fixed_layout_class.swift index 0941e30f614c0..bec20eb350c4e 100644 --- a/test/IRGen/fixed_layout_class.swift +++ b/test/IRGen/fixed_layout_class.swift @@ -10,7 +10,7 @@ // This tests @_fixed_layout classes in resilient modules. import fixed_layout_class -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience20useRootClassPropertyyy013fixed_layout_A0026OutsideParentWithResilientF0CF"(%T18fixed_layout_class34OutsideParentWithResilientPropertyC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience20useRootClassPropertyyy013fixed_layout_A0026OutsideParentWithResilientF0CF"(%T18fixed_layout_class34OutsideParentWithResilientPropertyC* %0) public func useRootClassProperty(_ o: OutsideParentWithResilientProperty) { // CHECK: getelementptr inbounds %T18fixed_layout_class34OutsideParentWithResilientPropertyC, %T18fixed_layout_class34OutsideParentWithResilientPropertyC* %0, i32 0, i32 1 _ = o.p @@ -21,7 +21,7 @@ public func useRootClassProperty(_ o: OutsideParentWithResilientProperty) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience19useSubclassPropertyyy013fixed_layout_A012OutsideChildCF"(%T18fixed_layout_class12OutsideChildC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience19useSubclassPropertyyy013fixed_layout_A012OutsideChildCF"(%T18fixed_layout_class12OutsideChildC* %0) public func useSubclassProperty(_ o: OutsideChild) { // CHECK: getelementptr inbounds %T18fixed_layout_class13OutsideParentC, %T18fixed_layout_class13OutsideParentC* %4, i32 0, i32 1 _ = o.property @@ -30,7 +30,7 @@ public func useSubclassProperty(_ o: OutsideChild) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience27useGenericRootClassPropertyyy013fixed_layout_A00D13OutsideParentCyxGlF"(%T18fixed_layout_class20GenericOutsideParentC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience27useGenericRootClassPropertyyy013fixed_layout_A00D13OutsideParentCyxGlF"(%T18fixed_layout_class20GenericOutsideParentC* %0) public func useGenericRootClassProperty(_ o: GenericOutsideParent) { // -- we load the base offset twice, first to get the generic parameter out and // then for the property itself. @@ -52,7 +52,7 @@ public func useGenericRootClassProperty(_ o: GenericOutsideParent) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience27useGenericRootClassPropertyyy013fixed_layout_A00D13OutsideParentCySiGF"(%T18fixed_layout_class20GenericOutsideParentCySiG*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience27useGenericRootClassPropertyyy013fixed_layout_A00D13OutsideParentCySiGF"(%T18fixed_layout_class20GenericOutsideParentCySiG* %0) public func useGenericRootClassProperty(_ o: GenericOutsideParent) { // CHECK: getelementptr inbounds %T18fixed_layout_class20GenericOutsideParentCySiG, %T18fixed_layout_class20GenericOutsideParentCySiG* %0, i32 0, i32 1 _ = o.property @@ -60,7 +60,7 @@ public func useGenericRootClassProperty(_ o: GenericOutsideParent) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience26useGenericSubclassPropertyyy013fixed_layout_A00D12OutsideChildCyxGlF"(%T18fixed_layout_class19GenericOutsideChildC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience26useGenericSubclassPropertyyy013fixed_layout_A00D12OutsideChildCyxGlF"(%T18fixed_layout_class19GenericOutsideChildC* %0) public func useGenericSubclassProperty(_ o: GenericOutsideChild) { // -- we load the base offset twice, first to get the generic parameter out and // then for the property itself. @@ -95,7 +95,7 @@ public func useGenericSubclassProperty(_ o: GenericOutsideChild) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience26useGenericSubclassPropertyyy013fixed_layout_A00D12OutsideChildCySiGF"(%T18fixed_layout_class19GenericOutsideChildCySiG*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience26useGenericSubclassPropertyyy013fixed_layout_A00D12OutsideChildCySiGF"(%T18fixed_layout_class19GenericOutsideChildCySiG* %0) public func useGenericSubclassProperty(_ o: GenericOutsideChild) { // CHECK: [[UPCAST:%.*]] = bitcast %T18fixed_layout_class19GenericOutsideChildCySiG* %0 to %T18fixed_layout_class20GenericOutsideParentCySiG* // CHECK: getelementptr inbounds %T18fixed_layout_class20GenericOutsideParentCySiG, %T18fixed_layout_class20GenericOutsideParentCySiG* [[UPCAST]], i32 0, i32 1 @@ -107,7 +107,7 @@ public func useGenericSubclassProperty(_ o: GenericOutsideChild) { // CHECK: ret void } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience17callVirtualMethodyy013fixed_layout_A013OutsideParentCF"(%T18fixed_layout_class13OutsideParentC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience17callVirtualMethodyy013fixed_layout_A013OutsideParentCF"(%T18fixed_layout_class13OutsideParentC* %0) public func callVirtualMethod(_ o: OutsideParent) { // Note: virtual method calls still use dispatch thunks @@ -123,4 +123,4 @@ public func callVirtualMethod(_ o: OutsideParent) { // Make sure we emit the dispatch thunk: -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience22MyChildOfOutsideParentC9newMethodyyFTj"(%T16class_resilience22MyChildOfOutsideParentC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s16class_resilience22MyChildOfOutsideParentC9newMethodyyFTj"(%T16class_resilience22MyChildOfOutsideParentC* swiftself %0) diff --git a/test/IRGen/fixlifetime.sil b/test/IRGen/fixlifetime.sil index 6ba29c06e56a2..bc05fde771f7a 100644 --- a/test/IRGen/fixlifetime.sil +++ b/test/IRGen/fixlifetime.sil @@ -8,7 +8,7 @@ // unnecessary. // ONONE-NOT: @__swift_fixLifetime -// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC*, %objc_object*, i8**, i8*, %swift.refcounted*, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC* %0, %objc_object* %1, i8** %2, i8* %3, %swift.refcounted* %4, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}}) %5) {{.*}} { // CHECK-objc: entry: // CHECK-objc: call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC* // CHECK-objc: call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%objc_object*)*)(%objc_object* @@ -18,7 +18,7 @@ // CHECK-objc: call void @__swift_fixLifetime(%swift.refcounted* // CHECK-objc: call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC**)*)(%T11fixlifetime1CC** -// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC*, %swift.refcounted*, i8**, i8*, %swift.refcounted*, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test(%T11fixlifetime1CC* %0, %swift.refcounted* %1, i8** %2, i8* %3, %swift.refcounted* %4, %T11fixlifetime3AggV* noalias nocapture dereferenceable({{.*}}) %5) {{.*}} { // CHECK-native: entry: // CHECK-native: call void bitcast (void (%swift.refcounted*)* @__swift_fixLifetime to void (%T11fixlifetime1CC*)*)(%T11fixlifetime1CC* // CHECK-native: call void @__swift_fixLifetime(%swift.refcounted* diff --git a/test/IRGen/fulfillment.sil b/test/IRGen/fulfillment.sil index 23442e28e201f..5cfea02b8ddda 100644 --- a/test/IRGen/fulfillment.sil +++ b/test/IRGen/fulfillment.sil @@ -18,7 +18,7 @@ protocol P { class B {} sil_vtable B {} -// CHECK-LABEL: define hidden swiftcc void @thick_metatype(%swift.type*) +// CHECK-LABEL: define hidden swiftcc void @thick_metatype(%swift.type* %0) sil hidden @thick_metatype : $@convention(thin) (@thick A.Type) -> () { bb0(%0 : $@thick A.Type): %2 = tuple () @@ -27,7 +27,7 @@ bb0(%0 : $@thick A.Type): sil hidden_external @use_all : $@convention(thin) () -> () -// CHECK-LABEL: define hidden swiftcc void @class_pointer(%T11fulfillment1BC*, i8** %T.P) +// CHECK-LABEL: define hidden swiftcc void @class_pointer(%T11fulfillment1BC* %0, i8** %T.P) // CHECK: [[T0:%.*]] = bitcast %T11fulfillment1BC* %0 to %swift.type** // CHECK-NEXT: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[T0]], align 8 // CHECK: [[T0:%.*]] = bitcast %swift.type* [[METADATA]] to %swift.type** @@ -47,7 +47,7 @@ bb0(%0 : $B): return %3 : $() } -// CHECK-LABEL: define hidden swiftcc void @test_23121786(%T11fulfillment1AC*, %T11fulfillment1AC{{.*}}*) +// CHECK-LABEL: define hidden swiftcc void @test_23121786(%T11fulfillment1AC* %0, %T11fulfillment1AC{{.*}}* %1) sil hidden @test_23121786 : $@convention(thin) (@owned A>, @owned A) -> () { bb0(%0 : $A>, %1 : $A): %2 = tuple () diff --git a/test/IRGen/function_param_convention.sil b/test/IRGen/function_param_convention.sil index 15ffc062481cc..eb71e6860e971 100644 --- a/test/IRGen/function_param_convention.sil +++ b/test/IRGen/function_param_convention.sil @@ -10,7 +10,7 @@ struct X { // Make sure we can irgen a SIL function with various parameter attributes // without choking. This is just a basic reality check. -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @foo(%T4Test1XV* noalias nocapture sret, %T4Test1XV* noalias nocapture dereferenceable({{.*}}), %T4Test1XV* nocapture dereferenceable({{.*}}), %T4Test1XV* noalias nocapture dereferenceable({{.*}}), i32, i32, i32) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @foo(%T4Test1XV* noalias nocapture sret %0, %T4Test1XV* noalias nocapture dereferenceable({{.*}}) %1, %T4Test1XV* nocapture dereferenceable({{.*}}) %2, %T4Test1XV* noalias nocapture dereferenceable({{.*}}) %3, i32 %4, i32 %5, i32 %6) {{.*}} { sil @foo : $@convention(thin) (@in X, @inout X, @in_guaranteed X, @owned X, X, @guaranteed X) -> @out X { bb0(%0 : $*X, %1 : $*X, %2 : $*X, %3 : $*X, %4 : $X, %5 : $X, %6 : $X): diff --git a/test/IRGen/function_types.sil b/test/IRGen/function_types.sil index 32974a22b289c..f1076e078feec 100644 --- a/test/IRGen/function_types.sil +++ b/test/IRGen/function_types.sil @@ -15,7 +15,7 @@ sil_stage canonical public protocol Protocol {} struct S : Protocol {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @thin_func_value(i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @thin_func_value(i8* %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: ret i8* %0 // CHECK-NEXT: } @@ -24,7 +24,7 @@ entry(%x : $@convention(thin) () -> ()): return %x : $@convention(thin) () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @thick_func_value(i8*, %swift.refcounted*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @thick_func_value(i8* %0, %swift.refcounted* %1) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %1) {{#[0-9]+}} // CHECK-NEXT: call void @swift_release(%swift.refcounted* %1) {{#[0-9]+}} @@ -39,7 +39,7 @@ entry(%x : $() -> ()): return %x : $() -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @thin_witness_value(i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @thin_witness_value(i8* %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: ret i8* %0 // CHECK-NEXT: } @@ -52,7 +52,7 @@ struct X {} sil @out_void_return : $@convention(thin) () -> @out X -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @use_void_return_value(%T14function_types1XV* noalias nocapture sret) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @use_void_return_value(%T14function_types1XV* noalias nocapture sret %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: call swiftcc void @out_void_return(%T14function_types1XV* noalias nocapture sret %0) // CHECK-NEXT: ret void @@ -64,7 +64,7 @@ entry(%x : $*X): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @test_function_to_pointer(i8*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @test_function_to_pointer(i8* %0) // CHECK-NEXT: entry: // CHECK-NEXT: ret i8* %0 sil @test_function_to_pointer : $@convention(thin) (@convention(thin) () -> ()) -> Builtin.RawPointer { @@ -73,7 +73,7 @@ bb0(%0 : $@convention(thin) () -> ()): return %1 : $Builtin.RawPointer } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @test_pointer_to_function(i8*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @test_pointer_to_function(i8* %0) // CHECK-NEXT: entry: // CHECK-NEXT: ret i8* %0 sil @test_pointer_to_function : $@convention(thin) (Builtin.RawPointer) -> @convention(thin) () -> () { diff --git a/test/IRGen/generic_casts.swift b/test/IRGen/generic_casts.swift index 8bff135238236..2f82f81b1d839 100644 --- a/test/IRGen/generic_casts.swift +++ b/test/IRGen/generic_casts.swift @@ -28,7 +28,7 @@ import gizmo // CHECK: @_PROTOCOL__TtP13generic_casts10ObjCProto1_ // CHECK: } -// CHECK: define hidden swiftcc i64 @"$s13generic_casts8allToIntySixlF"(%swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc i64 @"$s13generic_casts8allToIntySixlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T) func allToInt(_ x: T) -> Int { return x as! Int // CHECK: [[INT_TEMP:%.*]] = alloca %TSi, @@ -48,7 +48,7 @@ func allToInt(_ x: T) -> Int { // CHECK: ret i64 [[INT_RESULT]] } -// CHECK: define hidden swiftcc void @"$s13generic_casts8intToAllyxSilF"(%swift.opaque* noalias nocapture sret, i64, %swift.type* %T) {{.*}} { +// CHECK: define hidden swiftcc void @"$s13generic_casts8intToAllyxSilF"(%swift.opaque* noalias nocapture sret %0, i64 %1, %swift.type* %T) {{.*}} { func intToAll(_ x: Int) -> T { // CHECK: [[INT_TEMP:%.*]] = alloca %TSi, // CHECK: [[T0:%.*]] = getelementptr inbounds %TSi, %TSi* [[INT_TEMP]], i32 0, i32 0 @@ -58,7 +58,7 @@ func intToAll(_ x: Int) -> T { return x as! T } -// CHECK: define hidden swiftcc i64 @"$s13generic_casts8anyToIntySiypF"(%Any* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define hidden swiftcc i64 @"$s13generic_casts8anyToIntySiypF"(%Any* noalias nocapture dereferenceable({{.*}}) %0) {{.*}} { func anyToInt(_ x: Any) -> Int { return x as! Int } @@ -74,7 +74,7 @@ func anyToInt(_ x: Any) -> Int { @objc class ObjCClass {} -// CHECK: define hidden swiftcc %objc_object* @"$s13generic_casts9protoCastyAA10ObjCProto1_So9NSRuncingpAA0E6CClassCF"(%T13generic_casts9ObjCClassC*) {{.*}} { +// CHECK: define hidden swiftcc %objc_object* @"$s13generic_casts9protoCastyAA10ObjCProto1_So9NSRuncingpAA0E6CClassCF"(%T13generic_casts9ObjCClassC* %0) {{.*}} { func protoCast(_ x: ObjCClass) -> ObjCProto1 & NSRuncing { // CHECK: load i8*, i8** @"\01l_OBJC_PROTOCOL_REFERENCE_$__TtP13generic_casts10ObjCProto1_" // CHECK: load i8*, i8** @"\01l_OBJC_PROTOCOL_REFERENCE_$_NSRuncing" @@ -91,7 +91,7 @@ func protoCast(_ x: ObjCClass) -> ObjCProto1 & NSRuncing { // // Class existential to opaque archetype cast -// CHECK: define hidden swiftcc void @"$s13generic_casts33classExistentialToOpaqueArchetypeyxAA10ObjCProto1_plF"(%swift.opaque* noalias nocapture sret, %objc_object*, %swift.type* %T) +// CHECK: define hidden swiftcc void @"$s13generic_casts33classExistentialToOpaqueArchetypeyxAA10ObjCProto1_plF"(%swift.opaque* noalias nocapture sret %0, %objc_object* %1, %swift.type* %T) func classExistentialToOpaqueArchetype(_ x: ObjCProto1) -> T { var x = x // CHECK: [[X:%.*]] = alloca %T13generic_casts10ObjCProto1P @@ -105,7 +105,7 @@ func classExistentialToOpaqueArchetype(_ x: ObjCProto1) -> T { protocol P {} protocol Q {} -// CHECK: define hidden swiftcc void @"$s13generic_casts19compositionToMemberyAA1P_pAaC_AA1QpF{{.*}}"(%T13generic_casts1PP* noalias nocapture sret, %T13generic_casts1P_AA1Qp* noalias nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK: define hidden swiftcc void @"$s13generic_casts19compositionToMemberyAA1P_pAaC_AA1QpF{{.*}}"(%T13generic_casts1PP* noalias nocapture sret %0, %T13generic_casts1P_AA1Qp* noalias nocapture dereferenceable({{.*}}) %1) {{.*}} { func compositionToMember(_ a: P & Q) -> P { return a } diff --git a/test/IRGen/generic_class_anyobject.swift b/test/IRGen/generic_class_anyobject.swift index 402bebd3ff4ca..2dae038c072cc 100644 --- a/test/IRGen/generic_class_anyobject.swift +++ b/test/IRGen/generic_class_anyobject.swift @@ -4,6 +4,6 @@ func foo(_ x: T) -> T { return x } -// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s23generic_class_anyobject3baryyXlyXlF"(%objc_object*) +// CHECK-LABEL: define hidden swiftcc %objc_object* @"$s23generic_class_anyobject3baryyXlyXlF"(%objc_object* %0) // CHECK: call swiftcc %objc_object* @"$s23generic_class_anyobject3foo{{[_0-9a-zA-Z]*}}F" func bar(_ x: AnyObject) -> AnyObject { return foo(x) } diff --git a/test/IRGen/generic_classes.sil b/test/IRGen/generic_classes.sil index 2bd18e8013242..07e26d7f52789 100644 --- a/test/IRGen/generic_classes.sil +++ b/test/IRGen/generic_classes.sil @@ -341,24 +341,24 @@ entry(%c : $RootGeneric): } */ -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes11RootGenericCMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes11RootGenericCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[METADATA:%.*]] = call{{( tail)?}} %swift.type* @swift_allocateGenericClassMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc %swift.metadata_response @"$s15generic_classes11RootGenericCMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // -- initialize the dependent field offsets // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* [[METADATA]], i64 0, i64 3, i8*** {{%.*}}, i64* {{%.*}}) // CHECK: } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes22RootGenericFixedLayoutCMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes22RootGenericFixedLayoutCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[METADATA:%.*]] ={{( tail)?}} call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal swiftcc %swift.metadata_response @"$s15generic_classes22RootGenericFixedLayoutCMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* [[METADATA]], i64 0, i64 3, i8*** {{%.*}}, i64* {{%.*}}) // CHECK: } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes015GenericInheritsC0CMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s15generic_classes015GenericInheritsC0CMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // Bind the generic parameters. // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: %A = load %swift.type*, %swift.type** [[T0]] @@ -369,7 +369,7 @@ entry(%c : $RootGeneric): // CHECK-NEXT: ret %swift.type* [[METADATA]] // CHECK-LABEL: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s15generic_classes015GenericInheritsC0CMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // Initialize our own dependent field offsets. // CHECK: [[METADATA_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i64* @@ -400,5 +400,5 @@ entry(%c : $RootGeneric): // CHECK: ret %swift.metadata_response [[T1]] // CHECK: } -// OSIZE: define hidden swiftcc %swift.metadata_response @"$s15generic_classes11RootGenericCMa"(i64, %swift.type* {{.*}}) [[ATTRS:#[0-9]+]] { +// OSIZE: define hidden swiftcc %swift.metadata_response @"$s15generic_classes11RootGenericCMa"(i64 %0, %swift.type* {{.*}}) [[ATTRS:#[0-9]+]] { // OSIZE: [[ATTRS]] = {{{.*}}noinline diff --git a/test/IRGen/generic_metatypes.swift b/test/IRGen/generic_metatypes.swift index 86277c13953c1..2bc67e77b6321 100644 --- a/test/IRGen/generic_metatypes.swift +++ b/test/IRGen/generic_metatypes.swift @@ -23,7 +23,7 @@ public func type(of value: T) -> Metatype { never() } -// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture, %swift.type* [[TYPE:%.*]]) +// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture %0, %swift.type* [[TYPE:%.*]]) func genericTypeof(_ x: T) -> T.Type { // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false) // CHECK: ret %swift.type* [[METATYPE]] @@ -33,7 +33,7 @@ func genericTypeof(_ x: T) -> T.Type { struct Foo {} class Bar {} -// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC* %0) {{.*}} { func remapToSubstitutedMetatypes(_ x: Foo, y: Bar) -> (Foo.Type, Bar.Type) { @@ -58,7 +58,7 @@ func genericMetatypes(_ t: T.Type, _ u: U.Type) {} protocol Bas {} -// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}})) +// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}) %0) func protocolTypeof(_ x: Bas) -> Bas.Type { // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1 // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]] @@ -83,7 +83,7 @@ func metatypeErasure(_ z: Zim.Type) -> Bas.Type { return z } -// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type*) #0 +// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type* %0) func metatypeErasure(_ z: Zang.Type) -> Bas.Type { // CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0 // CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$s17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1 @@ -101,37 +101,37 @@ func genericMetatype(_ x: A.Type) {} // CHECK-LABEL: define hidden swiftcc void @"$s17generic_metatypes20makeGenericMetatypesyyF"() {{.*}} { func makeGenericMetatypes() { - // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s17generic_metatypes6OneArgVyAA3FooVGMD") [[NOUNWIND_READNONE:#[0-9]+]] + // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s17generic_metatypes6OneArgVyAA3FooVGMD") [[NOUNWIND_READNONE:#[0-9]+]] genericMetatype(OneArg.self) - // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMD") [[NOUNWIND_READNONE]] + // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMD") [[NOUNWIND_READNONE]] genericMetatype(TwoArgs.self) - // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMD") [[NOUNWIND_READNONE]] + // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMD") [[NOUNWIND_READNONE]] genericMetatype(ThreeArgs.self) - // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMD") [[NOUNWIND_READNONE]] + // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMD") [[NOUNWIND_READNONE]] genericMetatype(FourArgs.self) - // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMD") [[NOUNWIND_READNONE]] + // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMD") [[NOUNWIND_READNONE]] genericMetatype(FiveArgs.self) } // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes6OneArgVMa" -// CHECK-SAME: ([[INT]], %swift.type*) +// CHECK-SAME: ([[INT]] %0, %swift.type* %1) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* undef, i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes6OneArgVMn" {{.*}}) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes7TwoArgsVMa" -// CHECK-SAME: ([[INT]], %swift.type*, %swift.type*) +// CHECK-SAME: ([[INT]] %0, %swift.type* %1, %swift.type* %2) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes7TwoArgsVMn" {{.*}}) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes9ThreeArgsVMa" -// CHECK-SAME: ({{i[0-9]+}}, %swift.type*, %swift.type*, %swift.type*) +// CHECK-SAME: ({{i[0-9]+}} %0, %swift.type* %1, %swift.type* %2, %swift.type* %3) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2 // CHECK: [[BITCAST_3:%.*]] = bitcast {{.*}} %3 @@ -139,7 +139,7 @@ func makeGenericMetatypes() { // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes8FiveArgsVMa" -// CHECK-SAME: ([[INT]], i8**) [[NOUNWIND_OPT:#[0-9]+]] +// CHECK-SAME: ([[INT]] %0, i8** %1) [[NOUNWIND_OPT:#[0-9]+]] // CHECK-NOT: alloc // CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, i8* {{.*}}, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes8FiveArgsVMn" {{.*}}) // CHECK-NOT: call void @llvm.lifetime.end diff --git a/test/IRGen/generic_metatypes_future.swift b/test/IRGen/generic_metatypes_future.swift index 4165c217fc6e1..99a9554ce3369 100644 --- a/test/IRGen/generic_metatypes_future.swift +++ b/test/IRGen/generic_metatypes_future.swift @@ -23,7 +23,7 @@ public func type(of value: T) -> Metatype { never() } -// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture, %swift.type* [[TYPE:%.*]]) +// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture %0, %swift.type* [[TYPE:%.*]]) func genericTypeof(_ x: T) -> T.Type { // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false) // CHECK: ret %swift.type* [[METATYPE]] @@ -33,7 +33,7 @@ func genericTypeof(_ x: T) -> T.Type { struct Foo {} class Bar {} -// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC* %0) {{.*}} { func remapToSubstitutedMetatypes(_ x: Foo, y: Bar) -> (Foo.Type, Bar.Type) { @@ -58,7 +58,7 @@ func genericMetatypes(_ t: T.Type, _ u: U.Type) {} protocol Bas {} -// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}})) +// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}) %0) func protocolTypeof(_ x: Bas) -> Bas.Type { // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1 // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]] @@ -83,7 +83,7 @@ func metatypeErasure(_ z: Zim.Type) -> Bas.Type { return z } -// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type*) #0 +// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type* %0) #0 func metatypeErasure(_ z: Zang.Type) -> Bas.Type { // CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0 // CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$s17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1 @@ -148,20 +148,20 @@ func makeGenericMetatypes() { } // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes6OneArgVMa" -// CHECK-SAME: ([[INT]], %swift.type*) +// CHECK-SAME: ([[INT]] %0, %swift.type* %1) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* undef, i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes6OneArgVMn" {{.*}}) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes7TwoArgsVMa" -// CHECK-SAME: ([[INT]], %swift.type*, %swift.type*) +// CHECK-SAME: ([[INT]] %0, %swift.type* %1, %swift.type* %2) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes7TwoArgsVMn" {{.*}}) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes9ThreeArgsVMa" -// CHECK-SAME: ({{i[0-9]+}}, %swift.type*, %swift.type*, %swift.type*) +// CHECK-SAME: ({{i[0-9]+}} %0, %swift.type* %1, %swift.type* %2, %swift.type* %3) // CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1 // CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2 // CHECK: [[BITCAST_3:%.*]] = bitcast {{.*}} %3 @@ -169,7 +169,7 @@ func makeGenericMetatypes() { // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes8FiveArgsVMa" -// CHECK-SAME: ([[INT]], i8**) [[NOUNWIND_OPT:#[0-9]+]] +// CHECK-SAME: ([[INT]] %0, i8** %1) [[NOUNWIND_OPT:#[0-9]+]] // CHECK-NOT: alloc // CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, i8* {{.*}}, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes8FiveArgsVMn" {{.*}}) // CHECK-NOT: call void @llvm.lifetime.end diff --git a/test/IRGen/generic_structs.sil b/test/IRGen/generic_structs.sil index 618a91ad82106..97d8d39abaaf4 100644 --- a/test/IRGen/generic_structs.sil +++ b/test/IRGen/generic_structs.sil @@ -131,7 +131,7 @@ struct Stringly { var size : Builtin.Int64 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i32 } @concrete_instances(i64, i32) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i32 } @concrete_instances(i64 %0, i32 %1) {{.*}} { // CHECK: entry: // CHECK: %2 = trunc i32 %1 to i21 // CHECK: %3 = zext i21 %2 to i32 @@ -191,7 +191,7 @@ entry(%0 : $*ComplexDynamic, %1 : $*Byteful, %2 : $*A, %3 : $*B, %4 : $*Ch return %v : $() } -// CHECK-LABEL: define{{( protected)?}} internal %swift.type* @"$s15generic_structs13SingleDynamicVMi"(%swift.type_descriptor*, i8**, i8*) +// CHECK-LABEL: define{{( protected)?}} internal %swift.type* @"$s15generic_structs13SingleDynamicVMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: %T = load %swift.type*, %swift.type** [[T0]], align 8 // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2, i64 16) @@ -199,7 +199,7 @@ entry(%0 : $*ComplexDynamic, %1 : $*Byteful, %2 : $*A, %3 : $*B, %4 : $*Ch // CHECK: } // CHECK-LABEL: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s15generic_structs13SingleDynamicVMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // Lay out fields. // CHECK: [[T0:%.*]] = bitcast %swift.type* [[METADATA]] to i32* // CHECK: [[T1:%.*]] = getelementptr inbounds i32, i32* [[T0]], i64 6 diff --git a/test/IRGen/generic_structs_future.sil b/test/IRGen/generic_structs_future.sil index caffde28b07cb..83c2b16816d03 100644 --- a/test/IRGen/generic_structs_future.sil +++ b/test/IRGen/generic_structs_future.sil @@ -132,7 +132,7 @@ struct Stringly { var size : Builtin.Int64 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i32 } @concrete_instances(i64, i32) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i32 } @concrete_instances(i64 %0, i32 %1) {{.*}} { // CHECK: entry: // CHECK: %2 = trunc i32 %1 to i21 // CHECK: %3 = zext i21 %2 to i32 @@ -192,7 +192,7 @@ entry(%0 : $*ComplexDynamic, %1 : $*Byteful, %2 : $*A, %3 : $*B, %4 : $*Ch return %v : $() } -// CHECK-LABEL: define{{( protected)?}} internal %swift.type* @"$s22generic_structs_future13SingleDynamicVMi"(%swift.type_descriptor*, i8**, i8*) +// CHECK-LABEL: define{{( protected)?}} internal %swift.type* @"$s22generic_structs_future13SingleDynamicVMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: %T = load %swift.type*, %swift.type** [[T0]], align 8 // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2, i64 24) @@ -200,7 +200,7 @@ entry(%0 : $*ComplexDynamic, %1 : $*Byteful, %2 : $*A, %3 : $*B, %4 : $*Ch // CHECK: } // CHECK-LABEL: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s22generic_structs_future13SingleDynamicVMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // Lay out fields. // CHECK: [[T0:%.*]] = bitcast %swift.type* [[METADATA]] to i32* // CHECK: [[T1:%.*]] = getelementptr inbounds i32, i32* [[T0]], i64 6 diff --git a/test/IRGen/generic_ternary.swift b/test/IRGen/generic_ternary.swift index ab56ba5ca8f2d..59c740cd05cbd 100644 --- a/test/IRGen/generic_ternary.swift +++ b/test/IRGen/generic_ternary.swift @@ -4,7 +4,7 @@ // struct OptionalStreamAdaptor { - // CHECK: define hidden swiftcc void @"$s15generic_ternary21OptionalStreamAdaptorV4next{{[_0-9a-zA-Z]*}}F"(%TSq{{.*}}* noalias nocapture sret, %swift.type* %"OptionalStreamAdaptor", %T15generic_ternary21OptionalStreamAdaptorV* nocapture swiftself dereferenceable({{.*}})) + // CHECK: define hidden swiftcc void @"$s15generic_ternary21OptionalStreamAdaptorV4next{{[_0-9a-zA-Z]*}}F"(%TSq{{.*}}* noalias nocapture sret %0, %swift.type* %"OptionalStreamAdaptor", %T15generic_ternary21OptionalStreamAdaptorV* nocapture swiftself dereferenceable({{.*}}) %1) mutating func next() -> Optional { return x[0].next() diff --git a/test/IRGen/generic_tuples.swift b/test/IRGen/generic_tuples.swift index 84e5e5965a540..0def576522881 100644 --- a/test/IRGen/generic_tuples.swift +++ b/test/IRGen/generic_tuples.swift @@ -12,7 +12,7 @@ // CHECK: %swift.tuple_element_type = type { [[TYPE]]*, i32 } func dup(_ x: T) -> (T, T) { var x = x; return (x,x) } -// CHECK: define hidden swiftcc void @"$s14generic_tuples3dupyx_xtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc void @"$s14generic_tuples3dupyx_xtxlF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) // CHECK: entry: // Allocate a local variable for 'x'. // CHECK: [[TYPE_ADDR:%.*]] = bitcast %swift.type* %T to i8*** @@ -49,7 +49,7 @@ func callDup(_ s: S) { _ = dup(s) } class C {} func dupC(_ x: T) -> (T, T) { return (x, x) } -// CHECK-LABEL: define hidden swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$s14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$s14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC* %0, %swift.type* %T) // CHECK-NEXT: entry: // CHECK: [[REF:%.*]] = bitcast %T14generic_tuples1CC* %0 to %swift.refcounted* // CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[REF]]) @@ -60,7 +60,7 @@ func dupC(_ x: T) -> (T, T) { return (x, x) } // CHECK-NEXT: ret { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUP2]] func callDupC(_ c: C) { _ = dupC(c) } -// CHECK-LABEL: define hidden swiftcc void @"$s14generic_tuples8callDupCyyAA1CCF"(%T14generic_tuples1CC*) +// CHECK-LABEL: define hidden swiftcc void @"$s14generic_tuples8callDupCyyAA1CCF"(%T14generic_tuples1CC* %0) // CHECK-NEXT: entry: // CHECK: [[REQUEST:%.*]] = call {{.*}} @"$s14generic_tuples1CCMa" // CHECK-NEXT: [[METATYPE:%.*]] = extractvalue {{.*}} [[REQUEST]] @@ -71,22 +71,22 @@ func callDupC(_ c: C) { _ = dupC(c) } // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]]) // CHECK-NEXT: ret void -// CHECK: define hidden swiftcc i64 @"$s14generic_tuples4lumpySi_xxtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc i64 @"$s14generic_tuples4lumpySi_xxtxlF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) func lump(_ x: T) -> (Int, T, T) { return (0,x,x) } -// CHECK: define hidden swiftcc { i64, i64 } @"$s14generic_tuples5lump2ySi_SixtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc { i64, i64 } @"$s14generic_tuples5lump2ySi_SixtxlF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type* %T) func lump2(_ x: T) -> (Int, Int, T) { return (0,0,x) } -// CHECK: define hidden swiftcc void @"$s14generic_tuples5lump3yx_xxtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc void @"$s14generic_tuples5lump3yx_xxtxlF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.opaque* noalias nocapture %3, %swift.type* %T) func lump3(_ x: T) -> (T, T, T) { return (x,x,x) } -// CHECK: define hidden swiftcc i64 @"$s14generic_tuples5lump4yx_SixtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc i64 @"$s14generic_tuples5lump4yx_SixtxlF"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) func lump4(_ x: T) -> (T, Int, T) { return (x,0,x) } -// CHECK: define hidden swiftcc i64 @"$s14generic_tuples6unlumpyS2i_xxt_tlF"(i64, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc i64 @"$s14generic_tuples6unlumpyS2i_xxt_tlF"(i64 %0, %swift.opaque* noalias nocapture %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) func unlump(_ x: (Int, T, T)) -> Int { return x.0 } -// CHECK: define hidden swiftcc void @"$s14generic_tuples7unlump1yxSi_xxt_tlF"(%swift.opaque* noalias nocapture sret, i64, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc void @"$s14generic_tuples7unlump1yxSi_xxt_tlF"(%swift.opaque* noalias nocapture sret %0, i64 %1, %swift.opaque* noalias nocapture %2, %swift.opaque* noalias nocapture %3, %swift.type* %T) func unlump1(_ x: (Int, T, T)) -> T { return x.1 } -// CHECK: define hidden swiftcc void @"$s14generic_tuples7unlump2yxx_Sixt_tlF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, i64, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc void @"$s14generic_tuples7unlump2yxx_Sixt_tlF"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, i64 %2, %swift.opaque* noalias nocapture %3, %swift.type* %T) func unlump2(_ x: (T, Int, T)) -> T { return x.0 } -// CHECK: define hidden swiftcc i64 @"$s14generic_tuples7unlump3ySix_Sixt_tlF"(%swift.opaque* noalias nocapture, i64, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc i64 @"$s14generic_tuples7unlump3ySix_Sixt_tlF"(%swift.opaque* noalias nocapture %0, i64 %1, %swift.opaque* noalias nocapture %2, %swift.type* %T) func unlump3(_ x: (T, Int, T)) -> Int { return x.1 } diff --git a/test/IRGen/generic_types.swift b/test/IRGen/generic_types.swift index dcc12da11a05a..d19a5ace298a2 100644 --- a/test/IRGen/generic_types.swift +++ b/test/IRGen/generic_types.swift @@ -158,14 +158,14 @@ struct X2: P2 { struct X3 where U: P2, U.A: P1 { } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s13generic_types1ACMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s13generic_types1ACMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: %T = load %swift.type*, %swift.type** [[T0]], // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2) // CHECK-NEXT: ret %swift.type* [[METADATA]] // CHECK: } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s13generic_types1BCMi"(%swift.type_descriptor*, i8**, i8*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s13generic_types1BCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} { // CHECK: [[T0:%.*]] = bitcast i8** %1 to %swift.type** // CHECK: %T = load %swift.type*, %swift.type** [[T0]], // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2) diff --git a/test/IRGen/generic_vtable.swift b/test/IRGen/generic_vtable.swift index e2b15d444d58f..96ed3dcd70698 100644 --- a/test/IRGen/generic_vtable.swift +++ b/test/IRGen/generic_vtable.swift @@ -152,7 +152,7 @@ public class Concrete : Derived { //// Metadata initialization function for 'Derived' copies superclass vtable //// and installs overrides for 'm2()' and 'init()'. -// CHECK-LABEL: define internal %swift.type* @"$s14generic_vtable7DerivedCMi"(%swift.type_descriptor*, i8**, i8*) +// CHECK-LABEL: define internal %swift.type* @"$s14generic_vtable7DerivedCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // - 2 immediate members: // - type metadata for generic parameter T, @@ -161,7 +161,7 @@ public class Concrete : Derived { // CHECK: ret %swift.type* [[METADATA]] // CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s14generic_vtable7DerivedCMr" -// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8*, i8**) {{.*}} { +// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} { // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* [[METADATA]], [[INT]] 0, {{.*}}) // CHECK: ret %swift.metadata_response @@ -173,7 +173,7 @@ public class Concrete : Derived { //// Metadata response function for 'Concrete' is fairly simple. -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s14generic_vtable8ConcreteCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s14generic_vtable8ConcreteCMr"(%swift.type* %0, i8* %1, i8** %2) // -- ClassLayoutFlags is 256 / 0x100, HasStaticVTable // CHECK: call swiftcc %swift.metadata_response @swift_initClassMetadata2(%swift.type* %0, [[INT]] 256, {{.*}}) // CHECK: ret %swift.metadata_response diff --git a/test/IRGen/global_resilience.sil b/test/IRGen/global_resilience.sil index f7bc418851806..b8431ae4f2007 100644 --- a/test/IRGen/global_resilience.sil +++ b/test/IRGen/global_resilience.sil @@ -123,7 +123,7 @@ bb0: return %tuple : $() } -// CHECK-LABEL: define linkonce_odr hidden %swift.opaque* @__swift_allocate_value_buffer(%swift.type*, %swift.opaque*) +// CHECK-LABEL: define linkonce_odr hidden %swift.opaque* @__swift_allocate_value_buffer(%swift.type* %0, %swift.opaque* %1) // CHECK: entry: // CHECK: [[CAST:%.*]] = bitcast %swift.type* %0 to i8*** // CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{.*}} -1 @@ -154,7 +154,7 @@ bb0: // CHECK: ret %swift.opaque* [[PHI]] -// CHECK-LABEL: define linkonce_odr hidden %swift.opaque* @__swift_project_value_buffer(%swift.type*, %swift.opaque*) +// CHECK-LABEL: define linkonce_odr hidden %swift.opaque* @__swift_project_value_buffer(%swift.type* %0, %swift.opaque* %1) // CHECK: [[CAST:%.*]] = bitcast %swift.type* %0 to i8*** // CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{.*}} -1 // CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]] diff --git a/test/IRGen/globals.swift b/test/IRGen/globals.swift index 1fece018b535d..509922e9483ed 100644 --- a/test/IRGen/globals.swift +++ b/test/IRGen/globals.swift @@ -50,7 +50,7 @@ extension A { // CHECK-NOT: g8 // CHECK-NOT: g9 -// CHECK: define{{( dllexport)?}}{{( protected)?}} i32 @main(i32, i8**) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} i32 @main(i32 %0, i8** %1) {{.*}} { // CHECK: store i64 {{.*}}, i64* getelementptr inbounds ([[INT]], [[INT]]* @"$s7globals2g0Sivp", i32 0, i32 0), align 8 // FIXME: give these initializers a real mangled name diff --git a/test/IRGen/indexing.sil b/test/IRGen/indexing.sil index 07c06024a019a..a415524e14211 100644 --- a/test/IRGen/indexing.sil +++ b/test/IRGen/indexing.sil @@ -12,7 +12,7 @@ struct SameSizeStride { var x, y: Builtin.Int32 } // This type has unequal stride and size. struct DifferentSizeStride { var x: Builtin.Int32, y: Builtin.Int16 } -// CHECK: define{{( protected)?}} {{.*}}void @same_size_stride(%T8indexing14SameSizeStrideV* noalias nocapture dereferenceable({{.*}}), i64) {{.*}} { +// CHECK: define{{( protected)?}} {{.*}}void @same_size_stride(%T8indexing14SameSizeStrideV* noalias nocapture dereferenceable({{.*}}) %0, i64 %1) {{.*}} { // CHECK: getelementptr inbounds %T8indexing14SameSizeStrideV, %T8indexing14SameSizeStrideV* %0, i64 %1 sil @same_size_stride : $@convention(thin) (@in SameSizeStride, Builtin.Word) -> () { entry(%p : $*SameSizeStride, %i: $Builtin.Word): @@ -20,7 +20,7 @@ entry(%p : $*SameSizeStride, %i: $Builtin.Word): return undef : $() } -// CHECK: define{{( protected)?}} {{.*}}void @different_size_stride(%T8indexing19DifferentSizeStrideV* noalias nocapture dereferenceable({{.*}}), i64) {{.*}} { +// CHECK: define{{( protected)?}} {{.*}}void @different_size_stride(%T8indexing19DifferentSizeStrideV* noalias nocapture dereferenceable({{.*}}) %0, i64 %1) {{.*}} { // CHECK: %2 = bitcast %T8indexing19DifferentSizeStrideV* %0 to i8* // CHECK-NEXT: %3 = mul nsw i64 %1, 8 // CHECK-NEXT: %4 = getelementptr inbounds i8, i8* %2, i64 %3 @@ -31,7 +31,7 @@ entry(%p : $*DifferentSizeStride, %i: $Builtin.Word): return undef : $() } -// CHECK: define{{( protected)?}} {{.*}}void @zero_size(%swift.opaque* noalias nocapture, i64) {{.*}} { +// CHECK: define{{( protected)?}} {{.*}}void @zero_size(%swift.opaque* noalias nocapture %0, i64 %1) {{.*}} { // CHECK: %2 = bitcast %swift.opaque* %0 to i8* // CHECK-NEXT: %3 = mul nsw i64 %1, 1 // CHECK-NEXT: %4 = getelementptr inbounds i8, i8* %2, i64 %3 @@ -41,7 +41,7 @@ entry(%p : $*(), %i: $Builtin.Word): return undef : $() } -// CHECK: define{{( protected)?}} {{.*}}void @dynamic_size(%swift.opaque* noalias nocapture, i64, %swift.type* %T) {{.*}} { +// CHECK: define{{( protected)?}} {{.*}}void @dynamic_size(%swift.opaque* noalias nocapture %0, i64 %1, %swift.type* %T) {{.*}} { // CHECK: [[T0:%.*]] = bitcast %swift.type* %T to i8*** // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]], i64 -1 // CHECK-NEXT: [[VWT:%T.valueWitnesses]] = load i8**, i8*** [[T1]], align 8 diff --git a/test/IRGen/indirect_argument.sil b/test/IRGen/indirect_argument.sil index cf27e79ab8d8c..ea8ce00d0a4e8 100644 --- a/test/IRGen/indirect_argument.sil +++ b/test/IRGen/indirect_argument.sil @@ -12,7 +12,7 @@ struct HugeAlignment { } // TODO: could be the context param -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_method(%T17indirect_argument4HugeV* noalias nocapture swiftself dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_method(%T17indirect_argument4HugeV* noalias nocapture swiftself dereferenceable({{.*}}) %0) // CHECK-NOT: alloca // CHECK: call swiftcc void @huge_method(%T17indirect_argument4HugeV* noalias nocapture swiftself dereferenceable({{.*}}) %0) sil @huge_method : $@convention(method) (Huge) -> () { @@ -22,7 +22,7 @@ entry(%x : $Huge): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0) // CHECK-NOT: alloca // CHECK: call swiftcc void @huge_param(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0) sil @huge_param : $@convention(thin) (Huge) -> () { @@ -32,7 +32,7 @@ entry(%x : $Huge): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_alignment_param(%T17indirect_argument13HugeAlignmentV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_alignment_param(%T17indirect_argument13HugeAlignmentV* noalias nocapture dereferenceable({{.*}}) %0) // CHECK-NOT: alloca // CHECK: call swiftcc void @huge_alignment_param(%T17indirect_argument13HugeAlignmentV* noalias nocapture dereferenceable({{.*}}) %0) sil @huge_alignment_param : $@convention(thin) (HugeAlignment) -> () { @@ -42,7 +42,7 @@ entry(%x : $HugeAlignment): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param_and_return(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param_and_return(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1) // CHECK: [[TMP_RET:%.*]] = alloca // CHECK: call swiftcc void @huge_param_and_return(%T17indirect_argument4HugeV* noalias nocapture sret [[TMP_RET]], %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1) sil @huge_param_and_return : $@convention(thin) (Huge) -> Huge { @@ -52,7 +52,7 @@ entry(%x : $Huge): return %z : $Huge } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param_and_indirect_return(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_param_and_indirect_return(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1) // CHECK-NOT: alloca // CHECK: call swiftcc void @huge_param_and_indirect_return(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1) sil @huge_param_and_indirect_return : $@convention(thin) (Huge) -> @out Huge { @@ -62,12 +62,12 @@ entry(%o : $*Huge, %x : $Huge): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_partial_application(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_partial_application(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1) // CHECK-NOT: alloca // CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK: bitcast %swift.refcounted* [[CLOSURE]] to <{ %swift.refcounted, %T17indirect_argument4HugeV }>* // CHECK: call swiftcc void @"$s24huge_partial_applicationTA"(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0, %swift.refcounted* swiftself [[CLOSURE]]) -// CHECK: define internal swiftcc void @"$s24huge_partial_applicationTA"(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %swift.refcounted* swiftself) +// CHECK: define internal swiftcc void @"$s24huge_partial_applicationTA"(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0, %swift.refcounted* swiftself %1) // CHECK: [[TMP_ARG:%.*]] = alloca // CHECK-NOT: tail // CHECK: call swiftcc void @huge_partial_application(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) [[TMP_ARG]]) @@ -79,12 +79,12 @@ entry(%x : $Huge, %y : $Huge): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_partial_application_stret(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @huge_partial_application_stret(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %2) // CHECK: [[TMP_RET:%.*]] = alloca // CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK: bitcast %swift.refcounted* [[CLOSURE]] to <{ %swift.refcounted, %T17indirect_argument4HugeV }>* // CHECK: call swiftcc void @"$s30huge_partial_application_stretTA"(%T17indirect_argument4HugeV* noalias nocapture sret [[TMP_RET]], %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1, %swift.refcounted* swiftself [[CLOSURE]]) -// CHECK: define internal swiftcc void @"$s30huge_partial_application_stretTA"(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %swift.refcounted* swiftself) +// CHECK: define internal swiftcc void @"$s30huge_partial_application_stretTA"(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1, %swift.refcounted* swiftself %2) // CHECK: [[TMP_ARG:%.*]] = alloca // CHECK-NOT: tail // CHECK: call swiftcc void @huge_partial_application_stret(%T17indirect_argument4HugeV* noalias nocapture sret %0, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) [[TMP_ARG]]) diff --git a/test/IRGen/infinite_archetype.swift b/test/IRGen/infinite_archetype.swift index 248a5a9482fea..46c4d5184a947 100644 --- a/test/IRGen/infinite_archetype.swift +++ b/test/IRGen/infinite_archetype.swift @@ -6,5 +6,5 @@ protocol Fooable { associatedtype Foo } -// CHECK: define hidden swiftcc void @"$s18infinite_archetype3foo{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.Fooable) +// CHECK: define hidden swiftcc void @"$s18infinite_archetype3foo{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, i8** %T.Fooable) func foo(x: T) -> T where T == T.Foo { return x } diff --git a/test/IRGen/lazy_multi_file.swift b/test/IRGen/lazy_multi_file.swift index 78a4a137a3ce0..6b39a86fb0d5e 100644 --- a/test/IRGen/lazy_multi_file.swift +++ b/test/IRGen/lazy_multi_file.swift @@ -13,7 +13,7 @@ class Subclass : LazyContainerClass { // an indirect return value. When it shrinks back, remove the optional // indirect out. // - // CHECK-LABEL: @"$s15lazy_multi_file8SubclassC6getStrSSyF"({{(\%TSS\* noalias nocapture sret, )?}}%T15lazy_multi_file8SubclassC* swiftself) {{.*}} { + // CHECK-LABEL: @"$s15lazy_multi_file8SubclassC6getStrSSyF"({{(\%TSS\* noalias nocapture sret, )?}}%T15lazy_multi_file8SubclassC* swiftself %0) {{.*}} { func getStr() -> String { // CHECK: = getelementptr inbounds %T15lazy_multi_file8SubclassC, %T15lazy_multi_file8SubclassC* %0, i32 0, i32 3 return str diff --git a/test/IRGen/lifetime.sil b/test/IRGen/lifetime.sil index 18b8db234bbed..4e07ae0d912d8 100644 --- a/test/IRGen/lifetime.sil +++ b/test/IRGen/lifetime.sil @@ -17,7 +17,7 @@ bb0(%x : $*T): %0 = tuple () return %0 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @generic([[OPAQUE]]* noalias nocapture, [[TYPE]]* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @generic([[OPAQUE]]* noalias nocapture %0, [[TYPE]]* %T) {{.*}} { // Allocate it. // CHECK: [[TYPE_ADDR:%.*]] = bitcast %swift.type* %T to i8*** // CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[TYPE_ADDR]], {{(i32|i64)}} -1 @@ -56,7 +56,7 @@ bb0(%x : $*T): %0 = tuple () return %0 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @generic_with_reuse([[OPAQUE]]* noalias nocapture, [[TYPE]]* %T) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @generic_with_reuse([[OPAQUE]]* noalias nocapture %0, [[TYPE]]* %T) {{.*}} { // Allocate it. // CHECK: [[TYPE_ADDR:%.*]] = bitcast %swift.type* %T to i8*** // CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[TYPE_ADDR]], {{(i32|i64)}} -1 @@ -99,7 +99,7 @@ bb0(%x : $*Builtin.Int64): %0 = tuple () return %0 : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @fixed_size(i64* noalias nocapture dereferenceable(8)) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @fixed_size(i64* noalias nocapture dereferenceable(8) %0) // CHECK: [[XBUF:%.*]] = alloca i64 // CHECK-NEXT: [[XBUFLIFE:%.*]] = bitcast i64* [[XBUF]] to i8* // CHECK-NEXT: call void @llvm.lifetime.start.p0i8({{(i32|i64)}} 8, i8* [[XBUFLIFE]]) diff --git a/test/IRGen/metadata.swift b/test/IRGen/metadata.swift index dbd61ff466e6a..73fd1b6bda8c6 100644 --- a/test/IRGen/metadata.swift +++ b/test/IRGen/metadata.swift @@ -20,7 +20,7 @@ class G { var r = ResilientInt(i:1) } -// CHECK-LABEL: define {{.*}}swiftcc %swift.metadata_response @"$s1A12MyControllerCMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define {{.*}}swiftcc %swift.metadata_response @"$s1A12MyControllerCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK-NOT: ret // CHECK: call swiftcc %swift.metadata_response @"$s1A17InternalContainerVMa"( // CHECK: ret diff --git a/test/IRGen/metatype.sil b/test/IRGen/metatype.sil index 4761abd43dd21..1c1c802175910 100644 --- a/test/IRGen/metatype.sil +++ b/test/IRGen/metatype.sil @@ -19,7 +19,7 @@ sil @_TFC8metatype1Xd : $@convention(method) (@owned X) -> @owned Builtin.Native sil @_TFC8metatype1XD : $@convention(method) (@owned X) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @_TF8metatype22thick_to_objc_metatypeFT2xmMCS_1X_T_(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @_TF8metatype22thick_to_objc_metatypeFT2xmMCS_1X_T_(%swift.type* %0) sil @_TF8metatype22thick_to_objc_metatypeFT2xmMCS_1X_T_ : $@convention(thin) (@thick X.Type) -> @objc_metatype X.Type { bb0(%0 : $@thick X.Type): // CHECK: [[RESULT:%[0-9a-zA-Z_-]+]] = bitcast %swift.type* %0 to %objc_class* @@ -28,7 +28,7 @@ bb0(%0 : $@thick X.Type): return %1 : $@objc_metatype X.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @foreign_thick_to_objc(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @foreign_thick_to_objc(%swift.type* %0) sil @foreign_thick_to_objc : $@convention(thin) (@thick Gizmo.Type) -> @objc_metatype Gizmo.Type { bb0(%0 : $@thick Gizmo.Type): // CHECK: call %objc_class* @swift_getObjCClassFromMetadata @@ -37,7 +37,7 @@ bb0(%0 : $@thick Gizmo.Type): return %1 : $@objc_metatype Gizmo.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @_TF8metatype22objc_to_thick_metatypeFT2xmMCS_1X_T_(%objc_class*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @_TF8metatype22objc_to_thick_metatypeFT2xmMCS_1X_T_(%objc_class* %0) sil @_TF8metatype22objc_to_thick_metatypeFT2xmMCS_1X_T_ : $@convention(thin) (@objc_metatype X.Type) -> @thick X.Type { bb0(%0 : $@objc_metatype X.Type): // CHECK: [[RESULT:%[0-9a-zA-Z_-]+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* %0) @@ -46,7 +46,7 @@ bb0(%0 : $@objc_metatype X.Type): return %1 : $@thick X.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @foreign_objc_to_thick(%objc_class*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @foreign_objc_to_thick(%objc_class* %0) sil @foreign_objc_to_thick : $@convention(thin) (@objc_metatype Gizmo.Type) -> @thick Gizmo.Type { bb0(%0 : $@objc_metatype Gizmo.Type): // CHECK: [[RESULT:%[0-9a-zA-Z_-]+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* %0) @@ -65,7 +65,7 @@ entry: return %m : $@objc_metatype T.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @existential_objc_metatype(%objc_object*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_class* @existential_objc_metatype(%objc_object* %0) {{.*}} { // CHECK: entry: // CHECK-NEXT: [[METATYPE:%.*]] = call %objc_class* @swift_getObjCClassFromObject(%objc_object* %0) {{#[0-9]+}} // CHECK-NEXT: ret %objc_class* [[METATYPE]] @@ -81,7 +81,7 @@ public protocol ClassProto : AnyObject { var other: ClassProto? { get } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @drop_witness_table(%swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @drop_witness_table(%swift.type* %0, i8** %1) // CHECK: call %objc_class* @swift_getObjCClassFromMetadata(%swift.type* %0) // CHECK: ret void sil @drop_witness_table : $@convention(thin) (@thick ClassProto.Type) -> () { diff --git a/test/IRGen/metatype_casts.sil b/test/IRGen/metatype_casts.sil index a45330cc73321..0d18a18230f42 100644 --- a/test/IRGen/metatype_casts.sil +++ b/test/IRGen/metatype_casts.sil @@ -25,7 +25,7 @@ end: protocol P {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @existential_archetype_metatype_cast(%swift.type*, i8**, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @existential_archetype_metatype_cast(%swift.type* %0, i8** %1, %swift.type* %T) // CHECK: [[T0:%.*]] = call %swift.type* @swift_dynamicCastMetatype(%swift.type* %0, %swift.type* %T) // CHECK: [[T1:%.*]] = icmp ne %swift.type* [[T0]], null sil @existential_archetype_metatype_cast : $@convention(thin) (@thick P.Type) -> () { @@ -44,7 +44,7 @@ end: class SomeClass {} sil_vtable SomeClass {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @metatype_object_conversion(%objc_class*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @metatype_object_conversion(%objc_class* %0) {{.*}} { // CHECK: %1 = bitcast %objc_class* %0 to %objc_object* // CHECK: ret %objc_object* %1 // CHECK: } @@ -56,7 +56,7 @@ entry(%m : $@objc_metatype SomeClass.Type): protocol SomeClassProtocol : class {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @existential_metatype_object_conversion(%objc_class*, i8**) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_object* @existential_metatype_object_conversion(%objc_class* %0, i8** %1) {{.*}} { // CHECK: [[T0:%.*]] = bitcast %objc_class* %0 to %objc_object* // CHECK: ret %objc_object* [[T0]] // CHECK: } @@ -69,7 +69,7 @@ entry(%m : $@objc_metatype SomeClassProtocol.Type): class OtherClass : SomeClass {} sil_vtable OtherClass {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @value_metatype_cast(%T14metatype_casts9SomeClassC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @value_metatype_cast(%T14metatype_casts9SomeClassC* %0) // CHECK: [[T0:%.*]] = bitcast %T14metatype_casts9SomeClassC* %0 to %swift.type** // CHECK: [[T1:%.*]] = load %swift.type*, %swift.type** [[T0]] // CHECK-DIRECT: [[T2:%.*]] = icmp eq %swift.type* [[T1]], {{.*}} @"$s14metatype_casts10OtherClassCMf" diff --git a/test/IRGen/mixed_mode_class_with_unimportable_fields.swift b/test/IRGen/mixed_mode_class_with_unimportable_fields.swift index e77585424fb6b..dfd02d963228e 100644 --- a/test/IRGen/mixed_mode_class_with_unimportable_fields.swift +++ b/test/IRGen/mixed_mode_class_with_unimportable_fields.swift @@ -91,9 +91,9 @@ public func invokeMethod(on holder: SubButtHolder) { holder.subVirtual() } -// CHECK-V4-LABEL: define internal swiftcc %swift.metadata_response @"$s4main13SubButtHolderCMr"(%swift.type*, i8*, i8**) +// CHECK-V4-LABEL: define internal swiftcc %swift.metadata_response @"$s4main13SubButtHolderCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK-V4: call swiftcc %swift.metadata_response @swift_initClassMetadata2( -// CHECK-V4-LABEL: define internal swiftcc %swift.metadata_response @"$s4main03SubB10ButtHolderCMr"(%swift.type*, i8*, i8**) +// CHECK-V4-LABEL: define internal swiftcc %swift.metadata_response @"$s4main03SubB10ButtHolderCMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK-V4: call swiftcc %swift.metadata_response @swift_initClassMetadata2( diff --git a/test/IRGen/nested_generics.swift b/test/IRGen/nested_generics.swift index 87cbf273dff2e..44ac2ccba59b7 100644 --- a/test/IRGen/nested_generics.swift +++ b/test/IRGen/nested_generics.swift @@ -16,13 +16,13 @@ public func makeAMetadata() { } // Type constructor for OuterGenericStruct -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructVMa"(i64, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructVMa"(i64 %0, %swift.type* %1) // Type constructor for OuterGenericStruct.InnerGenericStruct -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructV05InnerdE0VMa"(i64, %swift.type*, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructV05InnerdE0VMa"(i64 %0, %swift.type* %1, %swift.type* %2) // Type constructor for OuterGenericStruct.InnerConcreteStruct -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructV013InnerConcreteE0VMa"(i64, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics18OuterGenericStructV013InnerConcreteE0VMa"(i64 %0, %swift.type* %1) public struct OuterGenericStruct { public struct InnerGenericStruct { @@ -40,13 +40,13 @@ public struct OuterGenericStruct { } // Type constructor for OuterGenericClass -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassCMa"(i64, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassCMa"(i64 %0, %swift.type* %1) // Type constructor for OuterGenericClass.InnerGenericClass -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassC05InnerdE0CMa"(i64, %swift.type*, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassC05InnerdE0CMa"(i64 %0, %swift.type* %1, %swift.type* %2) // Type constructor for OuterGenericClass.InnerConcreteClass -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassC013InnerConcreteE0CMa"(i64, %swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15nested_generics17OuterGenericClassC013InnerConcreteE0CMa"(i64 %0, %swift.type* %1) public class OuterGenericClass { public class InnerGenericClass { diff --git a/test/IRGen/nested_types.sil b/test/IRGen/nested_types.sil index 33f4a23d4a808..1151a0a6cc8fd 100644 --- a/test/IRGen/nested_types.sil +++ b/test/IRGen/nested_types.sil @@ -19,7 +19,7 @@ bb0(%0 : $@thick Outer.Inner.Type): %1 = metatype $@thick Outer.Type return %1 : $@thick Outer.Type } -// CHECK-LABEL: define{{ | dllexport | protected }}swiftcc %swift.type* @test0(%swift.type*) +// CHECK-LABEL: define{{ | dllexport | protected }}swiftcc %swift.type* @test0(%swift.type* %0) // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s12nested_types5OuterCMa"([[INT]] 0) // CHECK-NEXT: [[T1:%.*]] = extractvalue %swift.metadata_response [[T0]], 0 // CHECK-NEXT: ret %swift.type* [[T1]] diff --git a/test/IRGen/objc.swift b/test/IRGen/objc.swift index 424cebccbacab..0f03f87eb80ab 100644 --- a/test/IRGen/objc.swift +++ b/test/IRGen/objc.swift @@ -39,14 +39,14 @@ struct id { // Class and methods are [objc] by inheritance. class MyBlammo : Blammo { func foo() {} -// CHECK: define hidden swiftcc void @"$s4objc8MyBlammoC3fooyyF"([[MYBLAMMO]]* swiftself) {{.*}} { +// CHECK: define hidden swiftcc void @"$s4objc8MyBlammoC3fooyyF"([[MYBLAMMO]]* swiftself %0) {{.*}} { // CHECK: ret void } // Class and methods are [objc] by inheritance. class Test2 : Gizmo { func foo() {} -// CHECK: define hidden swiftcc void @"$s4objc5Test2C3fooyyF"([[TEST2]]* swiftself) {{.*}} { +// CHECK: define hidden swiftcc void @"$s4objc5Test2C3fooyyF"([[TEST2]]* swiftself %0) {{.*}} { // CHECK: ret void @objc dynamic func bar() {} @@ -70,7 +70,7 @@ class Octogenarian : Contrarian { @_silgen_name("unknown") func unknown(_ x: id) -> id -// CHECK: define hidden swiftcc %objc_object* @"$s4objc5test0{{[_0-9a-zA-Z]*}}F"(%objc_object*) +// CHECK: define hidden swiftcc %objc_object* @"$s4objc5test0{{[_0-9a-zA-Z]*}}F"(%objc_object* %0) // CHECK-NOT: call {{.*}} @swift_unknownObjectRetain // CHECK: call {{.*}} @swift_unknownObjectRetain // CHECK-NOT: call {{.*}} @swift_unknownObjectRelease @@ -85,7 +85,7 @@ func test0(_ arg: id) -> id { } func test1(_ cell: Blammo) {} -// CHECK: define hidden swiftcc void @"$s4objc5test1{{[_0-9a-zA-Z]*}}F"([[BLAMMO]]*) {{.*}} { +// CHECK: define hidden swiftcc void @"$s4objc5test1{{[_0-9a-zA-Z]*}}F"([[BLAMMO]]* %0) {{.*}} { // CHECK-NEXT: entry // CHECK-NEXT: alloca // CHECK-NEXT: bitcast diff --git a/test/IRGen/objc_block.sil b/test/IRGen/objc_block.sil index 537cd5408951b..c88ddb7108924 100644 --- a/test/IRGen/objc_block.sil +++ b/test/IRGen/objc_block.sil @@ -14,7 +14,7 @@ entry(%b : $@convention(block) (Foo) -> Foo, %x : $Foo): %y = apply %b(%x) : $@convention(block) (Foo) -> Foo return %y : $Foo } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T10objc_block3FooC* @call_block(%objc_block*, %T10objc_block3FooC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T10objc_block3FooC* @call_block(%objc_block* %0, %T10objc_block3FooC* %1) {{.*}} { // CHECK: entry: // CHECK: [[T0:%.*]] = getelementptr inbounds %objc_block, %objc_block* %0, i32 0, i32 3 // CHECK: [[T1:%.*]] = load i8*, i8** [[T0]] diff --git a/test/IRGen/objc_block_storage.sil b/test/IRGen/objc_block_storage.sil index 046bba21d15f0..c0f18c106fb00 100644 --- a/test/IRGen/objc_block_storage.sil +++ b/test/IRGen/objc_block_storage.sil @@ -38,7 +38,7 @@ import gizmo // CHECK: i8* {{.*}} [[NSRECT_BLOCK_SIGNATURE]] // CHECK: } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @project_block_storage({ %objc_block, i8* }* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @project_block_storage({ %objc_block, i8* }* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: %1 = getelementptr inbounds { %objc_block, i8* }, { %objc_block, i8* }* %0, i32 0, i32 1 // CHECK-NEXT: %2 = load i8*, i8** %1, align 8 @@ -51,7 +51,7 @@ entry(%0 : $*@block_storage Builtin.RawPointer): return %p : $Builtin.RawPointer } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc fp128 @overaligned_project_block_storage({ %objc_block, fp128 }* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc fp128 @overaligned_project_block_storage({ %objc_block, fp128 }* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK-NEXT: entry: // CHECK-NEXT: %1 = getelementptr inbounds { %objc_block, fp128 }, { %objc_block, fp128 }* %0, i32 0, i32 1 // CHECK-NEXT: %2 = load fp128, fp128* %1, align 16 @@ -64,7 +64,7 @@ entry(%0 : $*@block_storage Builtin.FPIEEE128): return %p : $Builtin.FPIEEE128 } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_trivial({ %objc_block, i8* }* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_trivial({ %objc_block, i8* }* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: [[HEADER:%.*]] = getelementptr inbounds { %objc_block, i8* }, { %objc_block, i8* }* %0, i32 0, i32 0 // CHECK: [[T0:%.*]] = getelementptr inbounds %objc_block, %objc_block* [[HEADER]], i32 0, i32 0 // CHECK: store %objc_class* [[BLOCK_ISA]], %objc_class** [[T0]] @@ -86,7 +86,7 @@ entry(%0 : $*@block_storage Builtin.RawPointer): return %b : $@convention(block) () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} void @invoke_trivial(void (...)*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} void @invoke_trivial(void (...)* %0) {{.*}} { // CHECK: %1 = bitcast void (...)* %0 to { %objc_block, i8* }* // CHECK: %2 = getelementptr inbounds { %objc_block, i8* }, { %objc_block, i8* }* %1, i32 0, i32 1 sil @invoke_trivial : $@convention(c) (@inout_aliasable @block_storage Builtin.RawPointer) -> () { @@ -104,14 +104,14 @@ entry(%0 : $*@block_storage Builtin.RawPointer): sil @invoke_trivial_block_param : $@convention(c) (@inout_aliasable @block_storage Builtin.RawPointer, @convention(block) (Int) -> Int) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} i64 @invoke_trivial_with_arg(void (...)*, i64) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} i64 @invoke_trivial_with_arg(void (...)* %0, i64 %1) {{.*}} { // CHECK: ret i64 %1 sil @invoke_trivial_with_arg : $@convention(c) (@inout_aliasable @block_storage Builtin.RawPointer, Int) -> Int { entry(%0 : $*@block_storage Builtin.RawPointer, %1 : $Int): return %1 : $Int } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_nontrivial({ %objc_block, %swift.refcounted* }* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_nontrivial({ %objc_block, %swift.refcounted* }* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: [[HEADER:%.*]] = getelementptr inbounds // CHECK: [[T0:%.*]] = getelementptr inbounds %objc_block, %objc_block* [[HEADER]], i32 0, i32 0 // CHECK: store %objc_class* [[BLOCK_ISA]], %objc_class** [[T0]] @@ -149,7 +149,7 @@ entry(%0 : $*@block_storage Builtin.NativeObject): sil public_external @invoke_nontrivial : $@convention(c) (@inout_aliasable @block_storage Builtin.NativeObject) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_stret({ %objc_block, i8* }* nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %objc_block* @init_block_header_stret({ %objc_block, i8* }* nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: [[HEADER:%.*]] = getelementptr inbounds // CHECK: [[T0:%.*]] = getelementptr inbounds %objc_block, %objc_block* [[HEADER]], i32 0, i32 0 // CHECK: store %objc_class* [[BLOCK_ISA]], %objc_class** [[T0]] diff --git a/test/IRGen/objc_bridge.swift b/test/IRGen/objc_bridge.swift index eef063e5c76d3..a0d1bd778b64b 100644 --- a/test/IRGen/objc_bridge.swift +++ b/test/IRGen/objc_bridge.swift @@ -130,8 +130,8 @@ var NSS : NSString = NSString() // -- NSString methods don't convert 'self' extension NSString { - // CHECK: define internal [[OPAQUE:.*]]* @"$sSo8NSStringC11objc_bridgeE13nsstrFakePropABvgTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { - // CHECK: define internal void @"$sSo8NSStringC11objc_bridgeE13nsstrFakePropABvsTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$sSo8NSStringC11objc_bridgeE13nsstrFakePropABvgTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { + // CHECK: define internal void @"$sSo8NSStringC11objc_bridgeE13nsstrFakePropABvsTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc var nsstrFakeProp : NSString { get { return NSS @@ -139,20 +139,20 @@ extension NSString { set {} } - // CHECK: define internal [[OPAQUE:.*]]* @"$sSo8NSStringC11objc_bridgeE11nsstrResultAByFTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$sSo8NSStringC11objc_bridgeE11nsstrResultAByFTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { @objc func nsstrResult() -> NSString { return NSS } - // CHECK: define internal void @"$sSo8NSStringC11objc_bridgeE8nsstrArg1syAB_tFTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal void @"$sSo8NSStringC11objc_bridgeE8nsstrArg1syAB_tFTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc func nsstrArg(s s: NSString) { } } class Bas : NSObject { - // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11strRealPropSSvgTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { - // CHECK: define internal void @"$s11objc_bridge3BasC11strRealPropSSvsTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11strRealPropSSvgTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC11strRealPropSSvsTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc var strRealProp : String - // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11strFakePropSSvgTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { - // CHECK: define internal void @"$s11objc_bridge3BasC11strFakePropSSvsTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11strFakePropSSvgTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC11strFakePropSSvsTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc var strFakeProp : String { get { return "" @@ -160,12 +160,12 @@ class Bas : NSObject { set {} } - // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC13nsstrRealPropSo8NSStringCvgTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { - // CHECK: define internal void @"$s11objc_bridge3BasC13nsstrRealPropSo8NSStringCvsTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC13nsstrRealPropSo8NSStringCvgTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC13nsstrRealPropSo8NSStringCvsTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc var nsstrRealProp : NSString - // CHECK: define hidden swiftcc %TSo8NSStringC* @"$s11objc_bridge3BasC13nsstrFakePropSo8NSStringCvg"(%T11objc_bridge3BasC* swiftself) {{.*}} { - // CHECK: define internal void @"$s11objc_bridge3BasC13nsstrFakePropSo8NSStringCvsTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define hidden swiftcc %TSo8NSStringC* @"$s11objc_bridge3BasC13nsstrFakePropSo8NSStringCvg"(%T11objc_bridge3BasC* swiftself %0) {{.*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC13nsstrFakePropSo8NSStringCvsTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc var nsstrFakeProp : NSString { get { return NSS @@ -173,14 +173,14 @@ class Bas : NSObject { set {} } - // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC9strResultSSyFTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC9strResultSSyFTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { @objc func strResult() -> String { return "" } - // CHECK: define internal void @"$s11objc_bridge3BasC6strArg1sySS_tFTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC6strArg1sySS_tFTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc func strArg(s s: String) { } - // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11nsstrResultSo8NSStringCyFTo"([[OPAQUE:.*]]*, i8*) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE:.*]]* @"$s11objc_bridge3BasC11nsstrResultSo8NSStringCyFTo"([[OPAQUE:.*]]* %0, i8* %1) {{[#0-9]*}} { @objc func nsstrResult() -> NSString { return NSS } - // CHECK: define internal void @"$s11objc_bridge3BasC8nsstrArg1sySo8NSStringC_tFTo"([[OPAQUE:.*]]*, i8*, [[OPAQUE:.*]]*) {{[#0-9]*}} { + // CHECK: define internal void @"$s11objc_bridge3BasC8nsstrArg1sySo8NSStringC_tFTo"([[OPAQUE:.*]]* %0, i8* %1, [[OPAQUE:.*]]* %2) {{[#0-9]*}} { @objc func nsstrArg(s s: NSString) { } override init() { diff --git a/test/IRGen/objc_casts.sil b/test/IRGen/objc_casts.sil index 3fad2576f1df8..a09c14a6f36ad 100644 --- a/test/IRGen/objc_casts.sil +++ b/test/IRGen/objc_casts.sil @@ -12,7 +12,7 @@ sil_vtable SwiftClass {} protocol ClassProto : class {} -// CHECK-LABEL: define hidden swiftcc %TSo8NSObjectC* @checkedClassBoundCast(%swift.type*, %TSo8NSObjectC*, %swift.type* %T) #0 { +// CHECK-LABEL: define hidden swiftcc %TSo8NSObjectC* @checkedClassBoundCast(%swift.type* %0, %TSo8NSObjectC* %1, %swift.type* %T) #0 { // CHECK: [[OBJ:%.+]] = bitcast %TSo8NSObjectC* %1 to i8* // CHECK: call i8* @llvm.objc.retain(i8* [[OBJ]]) // CHECK: [[OPAQUE_OBJ:%.+]] = bitcast %TSo8NSObjectC* %1 to i8* @@ -31,7 +31,7 @@ bb0(%unused : $@thick T.Type, %obj : $NSObject): } // rdar://24924966 -// CHECK-LABEL: define hidden swiftcc void @metatype_to_objc_class(%swift.type*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @metatype_to_objc_class(%swift.type* %0, %swift.type* %T) // CHECK: [[T0:%.*]] = call %objc_object* @swift_dynamicCastMetatypeToObjectUnconditional(%swift.type* %0, {{.*}}) // TODO: is this really necessary? also, this really shouldn't use a direct reference // CHECK-NEXT: [[T1:%.*]] = bitcast %objc_object* [[T0]] to i8* @@ -46,7 +46,7 @@ bb0(%metatype : $@thick T.Type): return %tuple : $() } -// CHECK-LABEL: define hidden swiftcc void @opt_metatype_to_objc_class({{(i32|i64)}}, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @opt_metatype_to_objc_class({{(i32|i64)}} %0, %swift.type* %T) // CHECK: [[ARG:%.*]] = inttoptr {{.*}} %0 to %swift.type* // CHECK: [[T0:%.*]] = call %objc_object* @swift_dynamicCastMetatypeToObjectUnconditional(%swift.type* [[ARG]], {{.*}}) // TODO: is this really necessary? also, this really shouldn't use a direct reference @@ -63,7 +63,7 @@ bb0(%metatype : $Optional<@thick T.Type>): } // CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @swift_class_bounded_to_cp -// CHECK-SAME: ([[SWIFTCLASS:%T10objc_casts10SwiftClassC]]*, %swift.type* %T) +// CHECK-SAME: ([[SWIFTCLASS:%T10objc_casts10SwiftClassC]]* %0, %swift.type* %T) // CHECK: [[T0:%.*]] = bitcast [[SWIFTCLASS]]* %0 to %swift.type** // CHECK-NEXT: [[TYPE:%.*]] = load %swift.type*, %swift.type** [[T0]], // CHECK-NEXT: [[T0:%.*]] = bitcast [[SWIFTCLASS]]* %0 to i8* @@ -75,7 +75,7 @@ entry(%a : $T): } // CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @objc_class_bounded_to_cp -// CHECK-SAME: ([[OBJCCLASS:%TSo8NSObjectC]]*, %swift.type* %T) +// CHECK-SAME: ([[OBJCCLASS:%TSo8NSObjectC]]* %0, %swift.type* %T) // CHECK: [[T0:%.*]] = bitcast [[OBJCCLASS]]* %0 to %objc_object* // CHECK-NEXT: [[TYPE:%.*]] = call %swift.type* @swift_getObjectType(%objc_object* [[T0]]) // CHECK-NEXT: [[T0:%.*]] = bitcast [[OBJCCLASS]]* %0 to i8* diff --git a/test/IRGen/objc_class_export.swift b/test/IRGen/objc_class_export.swift index 2c5b42125c4df..185b1919d6b58 100644 --- a/test/IRGen/objc_class_export.swift +++ b/test/IRGen/objc_class_export.swift @@ -81,7 +81,7 @@ struct BigStructWithNativeObjects { @objc func drawInRect(dirty dirty: NSRect) { } - // CHECK: define internal void @"$s17objc_class_export3FooC10drawInRect5dirtyySo6NSRectV_tFTo"([[OPAQUE:%.*]]*, i8*, [[NSRECT]]* byval align 8) {{[#0-9]*}} { + // CHECK: define internal void @"$s17objc_class_export3FooC10drawInRect5dirtyySo6NSRectV_tFTo"([[OPAQUE:%.*]]* %0, i8* %1, [[NSRECT]]* byval align 8 %2) {{[#0-9]*}} { // CHECK: [[CAST:%[a-zA-Z0-9]+]] = bitcast [[OPAQUE]]* %0 to [[FOO]]* // CHECK: call swiftcc void @"$s17objc_class_export3FooC10drawInRect5dirtyySo6NSRectV_tF"(double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, [[FOO]]* swiftself [[CAST]]) // CHECK: } @@ -90,14 +90,14 @@ struct BigStructWithNativeObjects { return NSRect(origin: NSPoint(x: 0, y: 0), size: NSSize(width: 0, height: 0)) } - // CHECK: define internal void @"$s17objc_class_export3FooC6boundsSo6NSRectVyFTo"([[NSRECT]]* noalias nocapture sret, [[OPAQUE4:%.*]]*, i8*) {{[#0-9]*}} { + // CHECK: define internal void @"$s17objc_class_export3FooC6boundsSo6NSRectVyFTo"([[NSRECT]]* noalias nocapture sret %0, [[OPAQUE4:%.*]]* %1, i8* %2) {{[#0-9]*}} { // CHECK: [[CAST:%[a-zA-Z0-9]+]] = bitcast [[OPAQUE4]]* %1 to [[FOO]]* // CHECK: call swiftcc { double, double, double, double } @"$s17objc_class_export3FooC6boundsSo6NSRectVyF"([[FOO]]* swiftself [[CAST]]) @objc func convertRectToBacking(r r: NSRect) -> NSRect { return r } - // CHECK: define internal void @"$s17objc_class_export3FooC20convertRectToBacking1rSo6NSRectVAG_tFTo"([[NSRECT]]* noalias nocapture sret, [[OPAQUE5:%.*]]*, i8*, [[NSRECT]]* byval align 8) {{[#0-9]*}} { + // CHECK: define internal void @"$s17objc_class_export3FooC20convertRectToBacking1rSo6NSRectVAG_tFTo"([[NSRECT]]* noalias nocapture sret %0, [[OPAQUE5:%.*]]* %1, i8* %2, [[NSRECT]]* byval align 8 %3) {{[#0-9]*}} { // CHECK: [[CAST:%[a-zA-Z0-9]+]] = bitcast [[OPAQUE5]]* %1 to [[FOO]]* // CHECK: call swiftcc { double, double, double, double } @"$s17objc_class_export3FooC20convertRectToBacking1rSo6NSRectVAG_tF"(double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, [[FOO]]* swiftself [[CAST]]) diff --git a/test/IRGen/objc_dealloc.sil b/test/IRGen/objc_dealloc.sil index 2c9a0624b62e4..15a33f7f18469 100644 --- a/test/IRGen/objc_dealloc.sil +++ b/test/IRGen/objc_dealloc.sil @@ -70,7 +70,7 @@ bb0(%0 : @unowned $X, %1 : @unowned $SwiftGizmo): return %7 : $() // id: %8 } -// CHECK: define internal void @"$s12objc_dealloc10SwiftGizmoCfDTo"([[OPAQUE:%.*]]*, i8*) {{[#0-9]*}} { +// CHECK: define internal void @"$s12objc_dealloc10SwiftGizmoCfDTo"([[OPAQUE:%.*]]* %0, i8* %1) {{[#0-9]*}} { sil [ossa] @$s12objc_dealloc10SwiftGizmoCfDTo : $@convention(objc_method) (SwiftGizmo) -> () { bb0(%0 : @unowned $SwiftGizmo): // CHECK-NEXT: entry diff --git a/test/IRGen/objc_deprecated_objc_thunks.swift b/test/IRGen/objc_deprecated_objc_thunks.swift index 967df75cf0152..46a1215764241 100644 --- a/test/IRGen/objc_deprecated_objc_thunks.swift +++ b/test/IRGen/objc_deprecated_objc_thunks.swift @@ -11,7 +11,7 @@ class ObjCSubclass : NSObject { func foo() { } } -// CHECK-LABEL: define hidden void @"$s016objc_deprecated_A7_thunks12ObjCSubclassC3fooyyFTo"(%0*, i8*) +// CHECK-LABEL: define hidden void @"$s016objc_deprecated_A7_thunks12ObjCSubclassC3fooyyFTo"(%0* %0, i8* %1) // CHECK: entry: // CHECK: [[SELF:%[0-9]+]] = bitcast %0* %0 to %objc_object* // CHECK-NEXT: call void @swift_objc_swift3ImplicitObjCEntrypoint(%objc_object* [[SELF]], i8* %1, i8* getelementptr inbounds ({{.*}}[[FILENAME_STR]]{{.*}}), i64 [[FILENAME_LENGTH:[0-9]+]], i64 11, i64 3, i8* {{.*}}) diff --git a/test/IRGen/objc_enum_multi_file.swift b/test/IRGen/objc_enum_multi_file.swift index 1ef5a4e160f6a..e5b3c144b0c5e 100644 --- a/test/IRGen/objc_enum_multi_file.swift +++ b/test/IRGen/objc_enum_multi_file.swift @@ -8,7 +8,7 @@ import objc_enum_multi_file_helper #endif -// CHECK-LABEL: define hidden swiftcc i32 @"$s4main6useFoo{{.*}}F"(i32) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i32 @"$s4main6useFoo{{.*}}F"(i32 %0) {{.*}} { func useFoo(_ x: Foo) -> Int32 { // CHECK: switch i32 %0, label %[[DEFAULT:.+]] [ // CHECK-DAG: i32 1, label %[[CASE_B:.+]] @@ -42,7 +42,7 @@ func useFoo(_ x: Foo) -> Int32 { // CHECK: ret i32 %[[RETVAL]] } -// CHECK-LABEL: define hidden swiftcc i32 @"$s4main6useBar{{.*}}F"(i32) {{.*}} { +// CHECK-LABEL: define hidden swiftcc i32 @"$s4main6useBar{{.*}}F"(i32 %0) {{.*}} { func useBar(_ x: Bar) -> Int32 { // CHECK: switch i32 %0, label %[[DEFAULT:.+]] [ // CHECK-DAG: i32 6, label %[[CASE_B:.+]] diff --git a/test/IRGen/objc_errors.sil b/test/IRGen/objc_errors.sil index 81e696b740cda..21313dd5745b1 100644 --- a/test/IRGen/objc_errors.sil +++ b/test/IRGen/objc_errors.sil @@ -7,7 +7,7 @@ import Swift import Foundation -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.error* @errortype_from_nserror(%TSo7NSErrorC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.error* @errortype_from_nserror(%TSo7NSErrorC* %0) // CHECK: %1 = bitcast %TSo7NSErrorC* %0 to %swift.error* sil @errortype_from_nserror : $@convention(thin) (@owned NSError) -> @owned Error { entry(%0 : $NSError): diff --git a/test/IRGen/objc_generic_class_convention.sil b/test/IRGen/objc_generic_class_convention.sil index 813dca634ef67..72a7a1f724f4d 100644 --- a/test/IRGen/objc_generic_class_convention.sil +++ b/test/IRGen/objc_generic_class_convention.sil @@ -13,13 +13,13 @@ import objc_generics // for them either, since they wouldn't be available through the polymorphic // convention for class methods. -// CHECK-LABEL: define swiftcc void @method(i64, %TSo12GenericClassC* swiftself) +// CHECK-LABEL: define swiftcc void @method(i64 %0, %TSo12GenericClassC* swiftself %1) sil @method : $@convention(method) @pseudogeneric (Int64, @guaranteed GenericClass) -> () { entry(%0 : $Int64, %1 : $GenericClass): return undef : $() } -// CHECK-LABEL: define void @objcMethod(i8*, i8*, i64) +// CHECK-LABEL: define void @objcMethod(i8* %0, i8* %1, i64 %2) sil @objcMethod : $@convention(objc_method) @pseudogeneric (Int64, @guaranteed GenericClass) -> () { entry(%0 : $Int64, %1 : $GenericClass): return undef : $() diff --git a/test/IRGen/objc_generic_class_metadata.sil b/test/IRGen/objc_generic_class_metadata.sil index f75002ae54df7..6c0fd81e057be 100644 --- a/test/IRGen/objc_generic_class_metadata.sil +++ b/test/IRGen/objc_generic_class_metadata.sil @@ -29,7 +29,7 @@ entry: // All instances of the generic ObjC class are erased to the same metadata // at runtime. - // CHECK: [[METADATA:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$sSo12GenericClassCMD") + // CHECK: [[METADATA:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$sSo12GenericClassCMD") %a = metatype $@thick GenericClass.Type // CHECK: call swiftcc void @metatype_sink(%swift.type* [[METADATA]], %swift.type* [[METADATA]]) apply %z>(%a) : $@convention(thin) (@thick T.Type) -> () @@ -45,7 +45,7 @@ entry: apply %y>(%c) : $@convention(thin) (@objc_metatype T.Type) -> () // Check that generic classes are erased at depth. - // CHECK: [[TUPLE_METADATA:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$sSaySo12GenericClassC_SitGMD") + // CHECK: [[TUPLE_METADATA:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$sSaySo12GenericClassC_SitGMD") %d = metatype $@thick Array<(GenericClass, Int)>.Type // CHECK: call swiftcc void @metatype_sink(%swift.type* [[TUPLE_METADATA]], %swift.type* [[TUPLE_METADATA]]) apply %z, Int)>>(%d) : $@convention(thin) (@thick T.Type) -> () @@ -80,7 +80,7 @@ class K {} sil @$useMeta : $@convention(thin)

() -> () -// CHECK-LABEL: define void @an_objc_method(i8*, i8*) +// CHECK-LABEL: define void @an_objc_method(i8* %0, i8* %1) // CHECK: [[C:%.*]] = bitcast i8* %0 to %objc_class* // CHECK: [[M:%.*]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[C]]) // CHECK: [[M2:%.*]] = bitcast %swift.type* [[M]] to %swift.type** @@ -98,7 +98,7 @@ bb0(%0 : $@objc_metatype K

): %4 = tuple () return %4 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_load_store_proto([[B]]* nocapture dereferenceable({{.*}}), i64, i64) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_load_store_proto([[B]]* nocapture dereferenceable({{.*}}) %0, i64 %1, i64 %2) // CHECK: [[X:%.*]] = getelementptr inbounds [[B]], [[B]]* %0, i32 0, i32 0 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 0 // CHECK-NEXT: [[T1:%.*]] = call [[UNKNOWN]]* @swift_unknownObjectWeakLoadStrong([[WEAK]]* [[T0]]) @@ -87,7 +87,7 @@ bb0(%0 : $Optional

): %4 = tuple () return %4 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_alloc_stack(i64, i64) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_alloc_stack(i64 %0, i64 %1) // CHECK: [[X:%.*]] = alloca { [[WEAK]], i8** }, align 8 // CHECK: [[TMPOBJ:%.*]] = inttoptr {{.*}} to %objc_object* // CHECK: [[TMPTAB:%.*]] = inttoptr {{.*}} to i8** diff --git a/test/IRGen/weak_class_protocol.sil b/test/IRGen/weak_class_protocol.sil index 7fc0aee0377c9..ef7655dcd49fb 100644 --- a/test/IRGen/weak_class_protocol.sil +++ b/test/IRGen/weak_class_protocol.sil @@ -6,7 +6,7 @@ import Swift protocol Foo: class { } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @store_weak({ %swift.weak, i8** }* noalias nocapture sret, i64, i64) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @store_weak({ %swift.weak, i8** }* noalias nocapture sret %0, i64 %1, i64 %2) {{.*}} { // CHECK: entry: // CHECK-objc: [[INSTANCE:%.*]] = inttoptr i64 %1 to %objc_object* // CHECK-native: [[INSTANCE:%.*]] = inttoptr i64 %1 to %swift.refcounted* diff --git a/test/IRGen/witness_method.sil b/test/IRGen/witness_method.sil index cb2dc81034c97..f343477e0ee05 100644 --- a/test/IRGen/witness_method.sil +++ b/test/IRGen/witness_method.sil @@ -9,7 +9,7 @@ protocol DefCon { } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defcon(%swift.opaque* noalias nocapture sret, %swift.type*, %swift.type* %T, i8** %T.DefCon) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defcon(%swift.opaque* noalias nocapture sret %0, %swift.type* %1, %swift.type* %T, i8** %T.DefCon) {{.*}} { sil @defcon : $@convention(thin) (@thick T.Type) -> @out T { entry(%0: $*T, %1: $@thick T.Type): @@ -62,7 +62,7 @@ struct SyncUp : Synergy { } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testGenericWitnessMethod(%swift.opaque* noalias nocapture sret, %T14witness_method6SyncUpV* noalias nocapture, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testGenericWitnessMethod(%swift.opaque* noalias nocapture sret %0, %T14witness_method6SyncUpV* noalias nocapture %1, %swift.type* %T) // CHECK: entry: // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s14witness_method6SyncUpVMa"([[INT]] 255, %swift.type* %T) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -91,7 +91,7 @@ protocol Strategy { func disrupt() -> GrowthHack } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testArchetypeWitnessMethod(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.Strategy) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testArchetypeWitnessMethod(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, i8** %T.Strategy) // CHECK: entry: // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %T.Strategy, i32 3 // CHECK: [[WITNESS_FN:%.*]] = load i8*, i8** [[WITNESS_ADDR]] @@ -115,7 +115,7 @@ class TPSReport : Strategy { func disrupt() -> GrowthHack } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @classArchetypeWitnessMethod(%T14witness_method9TPSReportC** noalias nocapture swiftself dereferenceable({{4|8}}), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @classArchetypeWitnessMethod(%T14witness_method9TPSReportC** noalias nocapture swiftself dereferenceable({{4|8}}) %0, %swift.type* %Self, i8** %SelfWitnessTable) sil @classArchetypeWitnessMethod : $@convention(witness_method: Strategy) > (@in_guaranteed T) -> () { entry(%self : $*T): @@ -123,7 +123,7 @@ entry(%self : $*T): return %z : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testClassArchetypeWitnessMethod(%T14witness_method7ToVideoV* noalias nocapture sret, %T14witness_method9TPSReportC** noalias nocapture dereferenceable({{4|8}}), %swift.type* %T, %swift.type* %CoverSheet) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @testClassArchetypeWitnessMethod(%T14witness_method7ToVideoV* noalias nocapture sret %0, %T14witness_method9TPSReportC** noalias nocapture dereferenceable({{4|8}}) %1, %swift.type* %T, %swift.type* %CoverSheet) // CHECK: entry: // CHECK: [[WITNESS_FN:%.*]] = load i8*, i8** getelementptr inbounds (i8*, i8** @"$s14witness_method9TPSReportCyxGAA8StrategyAAWP", i32 3) // CHECK: [[WITNESS:%.*]] = bitcast i8* [[WITNESS_FN]] to void (%swift.opaque*, %swift.opaque*, %swift.type*, i8**)* diff --git a/test/IRGen/witness_table_indirect_conformances.swift b/test/IRGen/witness_table_indirect_conformances.swift index 6867d8499432f..7554c607c8126 100644 --- a/test/IRGen/witness_table_indirect_conformances.swift +++ b/test/IRGen/witness_table_indirect_conformances.swift @@ -42,6 +42,6 @@ struct W: P3 { } // CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s35witness_table_indirect_conformances1ZVMa" -// CHECK-SAME: ([[INT]]) +// CHECK-SAME: ([[INT]] %0) // CHECK-NEXT: entry: // CHECK-NEXT: ret %swift.metadata_response { %swift.type* bitcast {{.*}} @"$s35witness_table_indirect_conformances1ZVMf", i32 0, i32 1) to %swift.type*), [[INT]] 0 } diff --git a/test/IRGen/witness_table_objc_associated_type.swift b/test/IRGen/witness_table_objc_associated_type.swift index de2e01fd1d536..9888dba964b27 100644 --- a/test/IRGen/witness_table_objc_associated_type.swift +++ b/test/IRGen/witness_table_objc_associated_type.swift @@ -35,7 +35,7 @@ struct SO: C { // CHECK: i8* bitcast {{.*}} @"$s34witness_table_objc_associated_type2SOVAA1CA2aDP3fooyyFTW" // CHECK: ] -// CHECK-LABEL: define hidden swiftcc void @"$s34witness_table_objc_associated_type0A25OffsetAfterAssociatedTypeyyxAA1BRzlF"(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.B) +// CHECK-LABEL: define hidden swiftcc void @"$s34witness_table_objc_associated_type0A25OffsetAfterAssociatedTypeyyxAA1BRzlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.B) func witnessOffsetAfterAssociatedType(_ x: T) { // CHECK: [[FOO_ADDR:%.*]] = getelementptr inbounds i8*, i8** %T.B, i32 3 // CHECK: [[FOO_OPAQUE:%.*]] = load {{.*}} [[FOO_ADDR]] @@ -44,7 +44,7 @@ func witnessOffsetAfterAssociatedType(_ x: T) { x.foo() } -// CHECK-LABEL: define hidden swiftcc void @"$s34witness_table_objc_associated_type0A29OffsetAfterAssociatedTypeObjCyyxAA1CRzlF"(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.C) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s34witness_table_objc_associated_type0A29OffsetAfterAssociatedTypeObjCyyxAA1CRzlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.C) {{.*}} { func witnessOffsetAfterAssociatedTypeObjC(_ x: T) { // CHECK: [[FOO_ADDR:%.*]] = getelementptr inbounds i8*, i8** %T.C, i32 2 // CHECK: [[FOO_OPAQUE:%.*]] = load {{.*}} [[FOO_ADDR]] diff --git a/test/IRGen/yield_once.sil b/test/IRGen/yield_once.sil index 45d46a88618dd..1c605bb8cc4e6 100644 --- a/test/IRGen/yield_once.sil +++ b/test/IRGen/yield_once.sil @@ -5,8 +5,8 @@ import Builtin sil @marker : $(Builtin.Int32) -> () // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @test_simple -// CHECK-32-SAME: i8* noalias dereferenceable([[BUFFER_SIZE:16]])) -// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]])) +// CHECK-32-SAME: i8* noalias dereferenceable([[BUFFER_SIZE:16]]) %0) +// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]) %0) // CHECK-SAME: [[CORO_ATTRIBUTES:#[0-9]+]] sil @test_simple : $@yield_once () -> () { entry: @@ -46,7 +46,7 @@ unwind: // CHECK-LABEL: declare{{( dllimport)?}}{{( protected)?}} swiftcc void @"$sIet_TC" // CHECK-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE]]), i1) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1 %0) sil @test_simple_call : $(Builtin.Int1) -> () { entry(%flag : $Builtin.Int1): // Allocate the buffer. diff --git a/test/IRGen/yield_once_big.sil b/test/IRGen/yield_once_big.sil index 74f09079cf7fa..0d9d9c3946f10 100644 --- a/test/IRGen/yield_once_big.sil +++ b/test/IRGen/yield_once_big.sil @@ -28,8 +28,8 @@ struct Big { sil @make_big : $ () -> (@owned Big) // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %T14yield_once_big3BigV* } @test_simple -// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]), %swift.type* %C) -// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]), %swift.type* %C) +// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]) %0, %swift.type* %C) +// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]) %0, %swift.type* %C) sil [ossa] @test_simple : $@yield_once () -> (@yields @owned Big) { entry: // Allocate space for the return value of make_big. @@ -89,7 +89,7 @@ unwind: // CHECK-LABEL: declare{{( dllimport)?}}{{( protected)?}} swiftcc void @"$s14yield_once_big9SomeClassCRbzlIet_TC" // CHECK-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE]]), i1) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1 %0) sil [ossa] @test_simple_call : $(Builtin.Int1) -> () { entry(%flag : $Builtin.Int1): // Allocate the buffer. diff --git a/test/IRGen/yield_once_biggish.sil b/test/IRGen/yield_once_biggish.sil index 5503a5134e525..064c0f2989e04 100644 --- a/test/IRGen/yield_once_biggish.sil +++ b/test/IRGen/yield_once_biggish.sil @@ -29,8 +29,8 @@ struct Biggish { sil @make_biggish : $ () -> (@owned Biggish) // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %T18yield_once_biggish9SomeClassC*, %T18yield_once_biggish9SomeClassC*, { %T18yield_once_biggish9SomeClassC*, %T18yield_once_biggish9SomeClassC* }* } @test_simple -// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]), %swift.type* %C) -// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]), %swift.type* %C) +// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]) %0, %swift.type* %C) +// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]) %0, %swift.type* %C) sil [ossa] @test_simple : $@yield_once () -> (@yields @owned Biggish) { entry: // Allocate space for the indirect spillover. @@ -97,7 +97,7 @@ unwind: // CHECK-LABEL: declare{{( dllimport)?}}{{( protected)?}} swiftcc void @"$s18yield_once_biggish9SomeClassCRbzlIet_TC" // CHECK-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE]]), i1) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1 %0) sil [ossa] @test_simple_call : $(Builtin.Int1) -> () { entry(%flag : $Builtin.Int1): // Allocate the buffer. diff --git a/test/IRGen/yield_once_indirect.sil b/test/IRGen/yield_once_indirect.sil index 27d54ab6550a1..1579427556d6b 100644 --- a/test/IRGen/yield_once_indirect.sil +++ b/test/IRGen/yield_once_indirect.sil @@ -20,8 +20,8 @@ struct Indirect { sil @make_indirect : $ () -> (@out Indirect) // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %T19yield_once_indirect8IndirectV* } @test_simple -// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]), %swift.type* %C) -// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]), %swift.type* %C) +// CHECK-32-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:16]]) %0, %swift.type* %C) +// CHECK-64-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE:32]]) %0, %swift.type* %C) sil @test_simple : $@yield_once () -> (@yields @in Indirect) { entry: // Allocate space for the return value of make_indirect. @@ -86,7 +86,7 @@ unwind: // CHECK-LABEL: declare{{( dllimport)?}}{{( protected)?}} swiftcc void @"$s19yield_once_indirect9SomeClassCRbzlIet_TC" // CHECK-SAME: (i8* noalias dereferenceable([[BUFFER_SIZE]]), i1) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_simple_call(i1 %0) sil @test_simple_call : $(Builtin.Int1) -> () { entry(%flag : $Builtin.Int1): // Allocate the buffer. diff --git a/test/Index/Store/Inputs/bridge-include.h b/test/Index/Store/Inputs/bridge-include.h index 55a072265f7a7..a8333148b1dae 100644 --- a/test/Index/Store/Inputs/bridge-include.h +++ b/test/Index/Store/Inputs/bridge-include.h @@ -1,2 +1,2 @@ int includedFunc(int a); -int MY_CONST = 2; \ No newline at end of file +int MY_CONST = 2; diff --git a/test/Inputs/conditional_conformance_basic_conformances.swift b/test/Inputs/conditional_conformance_basic_conformances.swift index 7743db428d8a8..cc890f809c99e 100644 --- a/test/Inputs/conditional_conformance_basic_conformances.swift +++ b/test/Inputs/conditional_conformance_basic_conformances.swift @@ -18,7 +18,7 @@ extension Single: P1 where A: P2 { // witness method for Single.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2_i8star:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -32,7 +32,7 @@ extension Single: P1 where A: P2 { // witness method for Single.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2_i8star:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -47,7 +47,7 @@ extension Single: P1 where A: P2 { public func single_generic(_: T.Type) { takes_p1(Single.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances14single_genericyyxmAA2P2RzlF"(%swift.type*, %swift.type* %T, i8** %T.P2) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances14single_genericyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [1 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6SingleVMa"(i64 0, %swift.type* %T) @@ -203,7 +203,7 @@ extension Double: P1 where B: P2, C: P3 { // witness method for Double.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[B_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[B_P2_i8star:%.*]] = load i8*, i8** [[B_P2_PTR]], align 8 @@ -227,7 +227,7 @@ extension Double: P1 where B: P2, C: P3 { // witness method for Double.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP7genericyyqd__AaGRd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP7genericyyqd__AaGRd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[B_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 @@ -254,7 +254,7 @@ extension Double: P1 where B: P2, C: P3 { public func double_generic_generic(_: U.Type, _: V.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances015double_generic_F0yyxm_q_mtAA2P2RzAA2P3R_r0_lF"(%swift.type*, %swift.type*, %swift.type* %U, %swift.type* %V, i8** %U.P2, i8** %V.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances015double_generic_F0yyxm_q_mtAA2P2RzAA2P3R_r0_lF"(%swift.type* %0, %swift.type* %1, %swift.type* %U, %swift.type* %V, i8** %U.P2, i8** %V.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [2 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6DoubleVMa"(i64 0, %swift.type* %U, %swift.type* %V) @@ -274,7 +274,7 @@ public func double_generic_generic(_: U.Type, _: V.Type) { public func double_generic_concrete(_: X.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances23double_generic_concreteyyxmAA2P2RzlF"(%swift.type*, %swift.type* %X, i8** %X.P2) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances23double_generic_concreteyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %X, i8** %X.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [2 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6DoubleVMa"(i64 0, %swift.type* %X, %swift.type* bitcast (i64* getelementptr inbounds (<{ i8**, i64, <{ {{.*}} }>* }>, <{ {{.*}} }>* @"$s42conditional_conformance_basic_conformances4IsP3VMf", i32 0, i32 1) to %swift.type*)) diff --git a/test/Inputs/conditional_conformance_basic_conformances_future.swift b/test/Inputs/conditional_conformance_basic_conformances_future.swift index 43eb345e7361e..9f6d5cc683bec 100644 --- a/test/Inputs/conditional_conformance_basic_conformances_future.swift +++ b/test/Inputs/conditional_conformance_basic_conformances_future.swift @@ -18,7 +18,7 @@ extension Single: P1 where A: P2 { // witness method for Single.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2_i8star:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -32,7 +32,7 @@ extension Single: P1 where A: P2 { // witness method for Single.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6SingleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2_i8star:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -47,7 +47,7 @@ extension Single: P1 where A: P2 { public func single_generic(_: T.Type) { takes_p1(Single.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances14single_genericyyxmAA2P2RzlF"(%swift.type*, %swift.type* %T, i8** %T.P2) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances14single_genericyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [1 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6SingleVMa"(i64 0, %swift.type* %T) @@ -201,7 +201,7 @@ extension Double: P1 where B: P2, C: P3 { // witness method for Double.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP6normalyyFTW"(%T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[B_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[B_P2_i8star:%.*]] = load i8*, i8** [[B_P2_PTR]], align 8 @@ -225,7 +225,7 @@ extension Double: P1 where B: P2, C: P3 { // witness method for Double.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP7genericyyqd__AaGRd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlAaEP7genericyyqd__AaGRd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T42conditional_conformance_basic_conformances6DoubleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[B_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 @@ -252,7 +252,7 @@ extension Double: P1 where B: P2, C: P3 { public func double_generic_generic(_: U.Type, _: V.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances015double_generic_F0yyxm_q_mtAA2P2RzAA2P3R_r0_lF"(%swift.type*, %swift.type*, %swift.type* %U, %swift.type* %V, i8** %U.P2, i8** %V.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances015double_generic_F0yyxm_q_mtAA2P2RzAA2P3R_r0_lF"(%swift.type* %0, %swift.type* %1, %swift.type* %U, %swift.type* %V, i8** %U.P2, i8** %V.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [2 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6DoubleVMa"(i64 0, %swift.type* %U, %swift.type* %V) @@ -272,7 +272,7 @@ public func double_generic_generic(_: U.Type, _: V.Type) { public func double_generic_concrete(_: X.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances23double_generic_concreteyyxmAA2P2RzlF"(%swift.type*, %swift.type* %X, i8** %X.P2) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s42conditional_conformance_basic_conformances23double_generic_concreteyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %X, i8** %X.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [2 x i8**], align 8 // CHECK: [[Double_TYPE_Response:%[0-9]+]] = call swiftcc %swift.metadata_response @"$s42conditional_conformance_basic_conformances6DoubleVMa"( diff --git a/test/Inputs/conditional_conformance_subclass.swift b/test/Inputs/conditional_conformance_subclass.swift index b16b58599d572..078f15b4abb0e 100644 --- a/test/Inputs/conditional_conformance_subclass.swift +++ b/test/Inputs/conditional_conformance_subclass.swift @@ -16,7 +16,7 @@ extension Base: P1 where A: P2 { // witness method for Base.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T32conditional_conformance_subclass4BaseC.0** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T32conditional_conformance_subclass4BaseC.0** noalias nocapture swiftself dereferenceable(8) %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -28,7 +28,7 @@ extension Base: P1 where A: P2 { // witness method for Base.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T32conditional_conformance_subclass4BaseC.1** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T32conditional_conformance_subclass4BaseC.1** noalias nocapture swiftself dereferenceable(8) %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -47,7 +47,7 @@ public func subclassgeneric_generic(_: T.Type) { takes_p1(SubclassGeneric.self) } -// CHECK-LABEL: define{{( dllexport| protected)?}} swiftcc void @"$s32conditional_conformance_subclass23subclassgeneric_genericyyxmAA2P2RzlF"(%swift.type*, %swift.type* %T, i8** %T.P2) +// CHECK-LABEL: define{{( dllexport| protected)?}} swiftcc void @"$s32conditional_conformance_subclass23subclassgeneric_genericyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [1 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s32conditional_conformance_subclass15SubclassGenericCMa"(i64 0, %swift.type* %T) diff --git a/test/Inputs/conditional_conformance_subclass_future.swift b/test/Inputs/conditional_conformance_subclass_future.swift index 84b9e773c483d..094d94a7aabc8 100644 --- a/test/Inputs/conditional_conformance_subclass_future.swift +++ b/test/Inputs/conditional_conformance_subclass_future.swift @@ -16,7 +16,7 @@ extension Base: P1 where A: P2 { // witness method for Base.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T32conditional_conformance_subclass4BaseC.0** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP6normalyyFTW"(%T32conditional_conformance_subclass4BaseC.0** noalias nocapture swiftself dereferenceable(8) %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -28,7 +28,7 @@ extension Base: P1 where A: P2 { // witness method for Base.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T32conditional_conformance_subclass4BaseC.1** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T32conditional_conformance_subclass4BaseC.1** noalias nocapture swiftself dereferenceable(8) %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[A_P2_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[A_P2:%.*]] = load i8*, i8** [[A_P2_PTR]], align 8 @@ -47,7 +47,7 @@ public func subclassgeneric_generic(_: T.Type) { takes_p1(SubclassGeneric.self) } -// CHECK-LABEL: define{{( dllexport| protected)?}} swiftcc void @"$s32conditional_conformance_subclass23subclassgeneric_genericyyxmAA2P2RzlF"(%swift.type*, %swift.type* %T, i8** %T.P2) +// CHECK-LABEL: define{{( dllexport| protected)?}} swiftcc void @"$s32conditional_conformance_subclass23subclassgeneric_genericyyxmAA2P2RzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [1 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s32conditional_conformance_subclass15SubclassGenericCMa"(i64 0, %swift.type* %T) diff --git a/test/Inputs/conditional_conformance_with_assoc.swift b/test/Inputs/conditional_conformance_with_assoc.swift index c561630f1d43a..3524e7edda75c 100644 --- a/test/Inputs/conditional_conformance_with_assoc.swift +++ b/test/Inputs/conditional_conformance_with_assoc.swift @@ -41,7 +41,7 @@ extension Double: P1 where B.AT2: P2, C: P3, B.AT2.AT2.AT3: P3 { // witness method for Double.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP6normalyyFTW"(%T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP6normalyyFTW"(%T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[C_P3_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[C_P3:%.*]] = load i8*, i8** [[C_P3_PTR]], align 8 @@ -73,7 +73,7 @@ extension Double: P1 where B.AT2: P2, C: P3, B.AT2.AT2.AT3: P3 { // witness method for Double.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP7genericyyqd__AaFRd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP7genericyyqd__AaFRd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[C_P3_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[C_P3:%.*]] = load i8*, i8** [[C_P3_PTR]], align 8 @@ -109,7 +109,7 @@ public func generic_generic(_: T.Type, _: U.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc08generic_E0yyxm_q_mtAA2P2RzAA2P3R_AaC3AT2RpzAadE_AeaCP3AT3RPzr0_lF"(%swift.type*, %swift.type*, %swift.type* %T, %swift.type* %U, i8** %T.P2, i8** %U.P3, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc08generic_E0yyxm_q_mtAA2P2RzAA2P3R_AaC3AT2RpzAadE_AeaCP3AT3RPzr0_lF"(%swift.type* %0, %swift.type* %1, %swift.type* %T, %swift.type* %U, i8** %T.P2, i8** %U.P3, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"(i64 0, %swift.type* %T, %swift.type* %U, i8** %T.P2) @@ -133,7 +133,7 @@ public func generic_concrete(_: T.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16generic_concreteyyxmAA2P2RzAaC3AT2RpzAA2P3AD_AdaCP3AT3RPzlF"(%swift.type*, %swift.type* %T, i8** %T.P2, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16generic_concreteyyxmAA2P2RzAaC3AT2RpzAA2P3AD_AdaCP3AT3RPzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"( @@ -176,7 +176,7 @@ public func concrete_generic(_: U.Type) takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16concrete_genericyyxmAA2P3RzlF"(%swift.type*, %swift.type* %U, i8** %U.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16concrete_genericyyxmAA2P3RzlF"(%swift.type* %0, %swift.type* %U, i8** %U.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"(i64 0, %swift.type* bitcast (i64* getelementptr inbounds (<{ {{.*}} }>, <{ {{.*}} }>* @"$s34conditional_conformance_with_assoc8IsAlsoP2VMf", i32 0, i32 1) to %swift.type*), %swift.type* %U, i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @"$s34conditional_conformance_with_assoc8IsAlsoP2VAA0G0AAWP", i32 0, i32 0)) diff --git a/test/Inputs/conditional_conformance_with_assoc_future.swift b/test/Inputs/conditional_conformance_with_assoc_future.swift index 429d689518e57..fb7b681388132 100644 --- a/test/Inputs/conditional_conformance_with_assoc_future.swift +++ b/test/Inputs/conditional_conformance_with_assoc_future.swift @@ -41,7 +41,7 @@ extension Double: P1 where B.AT2: P2, C: P3, B.AT2.AT2.AT3: P3 { // witness method for Double.normal -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP6normalyyFTW"(%T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP6normalyyFTW"(%T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[C_P3_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[C_P3:%.*]] = load i8*, i8** [[C_P3_PTR]], align 8 @@ -73,7 +73,7 @@ extension Double: P1 where B.AT2: P2, C: P3, B.AT2.AT2.AT3: P3 { // witness method for Double.generic -// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP7genericyyqd__AaFRd__lFTW"(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$s34conditional_conformance_with_assoc6DoubleVyxq_GAA2P1A2A2P3R_AA2P23AT2RpzAafH_AhaGP3AT3RPzrlAaEP7genericyyqd__AaFRd__lFTW"(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_1_0", i8** %"\CF\84_1_0.P3", %T34conditional_conformance_with_assoc6DoubleV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: // CHECK-NEXT: [[C_P3_PTR:%.*]] = getelementptr inbounds i8*, i8** %SelfWitnessTable, i32 -1 // CHECK-NEXT: [[C_P3:%.*]] = load i8*, i8** [[C_P3_PTR]], align 8 @@ -109,7 +109,7 @@ public func generic_generic(_: T.Type, _: U.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc08generic_E0yyxm_q_mtAA2P2RzAA2P3R_AaC3AT2RpzAadE_AeaCP3AT3RPzr0_lF"(%swift.type*, %swift.type*, %swift.type* %T, %swift.type* %U, i8** %T.P2, i8** %U.P3, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc08generic_E0yyxm_q_mtAA2P2RzAA2P3R_AaC3AT2RpzAadE_AeaCP3AT3RPzr0_lF"(%swift.type* %0, %swift.type* %1, %swift.type* %T, %swift.type* %U, i8** %T.P2, i8** %U.P3, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"(i64 0, %swift.type* %T, %swift.type* %U, i8** %T.P2) @@ -133,7 +133,7 @@ public func generic_concrete(_: T.Type) { takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16generic_concreteyyxmAA2P2RzAaC3AT2RpzAA2P3AD_AdaCP3AT3RPzlF"(%swift.type*, %swift.type* %T, i8** %T.P2, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16generic_concreteyyxmAA2P2RzAaC3AT2RpzAA2P3AD_AdaCP3AT3RPzlF"(%swift.type* %0, %swift.type* %T, i8** %T.P2, i8** %T.AT2.P2, i8** %T.AT2.AT2.AT3.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"( @@ -176,7 +176,7 @@ public func concrete_generic(_: U.Type) takes_p1(Double.self) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16concrete_genericyyxmAA2P3RzlF"(%swift.type*, %swift.type* %U, i8** %U.P3) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s34conditional_conformance_with_assoc16concrete_genericyyxmAA2P3RzlF"(%swift.type* %0, %swift.type* %U, i8** %U.P3) // CHECK-NEXT: entry: // CHECK: %conditional.requirement.buffer = alloca [3 x i8**], align 8 // CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s34conditional_conformance_with_assoc6DoubleVMa"(i64 0, %swift.type* bitcast (i64* getelementptr inbounds (<{ {{.*}} }>, <{ {{.*}} }>* @"$s34conditional_conformance_with_assoc8IsAlsoP2VMf", i32 0, i32 1) to %swift.type*), %swift.type* %U, i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @"$s34conditional_conformance_with_assoc8IsAlsoP2VAA0G0AAWP", i32 0, i32 0)) diff --git a/test/LLVMPasses/contract.ll b/test/LLVMPasses/contract.ll index 7fcc063b0ad86..130063a3fe60b 100644 --- a/test/LLVMPasses/contract.ll +++ b/test/LLVMPasses/contract.ll @@ -21,7 +21,7 @@ declare void @noread_user_bridged(%swift.bridge*) readnone declare void @user_bridged(%swift.bridge*) declare void @__swift_endBorrow(i8*, i8*) -; CHECK-LABEL: define{{( protected)?}} void @fixlifetime_removal(i8*) { +; CHECK-LABEL: define{{( protected)?}} void @fixlifetime_removal(i8* %0) { ; CHECK-NOT: call void @__swift_fixLifetime define void @fixlifetime_removal(i8*) { entry: @@ -30,7 +30,7 @@ entry: ret void } -; CHECK-LABEL: define{{( protected)?}} void @endBorrow_removal(i8*, i8*) { +; CHECK-LABEL: define{{( protected)?}} void @endBorrow_removal(i8* %0, i8* %1) { ; CHECK-NOT: call void @__swift_endBorrow define void @endBorrow_removal(i8*, i8*) { entry: diff --git a/test/LLVMPasses/llvm-aa.ll b/test/LLVMPasses/llvm-aa.ll index e8944ae8ddba2..4832af9887581 100644 --- a/test/LLVMPasses/llvm-aa.ll +++ b/test/LLVMPasses/llvm-aa.ll @@ -5,7 +5,7 @@ target triple = "x86_64-apple-macosx10.9" declare void @swift_retain(i8 *) nounwind -; CHECK-LABEL: define{{( protected)?}} i8 @test_eliminate_loads_over_retain(i8*) { +; CHECK-LABEL: define{{( protected)?}} i8 @test_eliminate_loads_over_retain(i8* %0) { ; CHECK: load ; CHECK-NOT: load define i8 @test_eliminate_loads_over_retain(i8*) { diff --git a/test/LLVMPasses/merge_func.ll b/test/LLVMPasses/merge_func.ll index 789547f87cf56..c7ce4438e0a29 100644 --- a/test/LLVMPasses/merge_func.ll +++ b/test/LLVMPasses/merge_func.ll @@ -30,7 +30,7 @@ define i32 @simple_func2(i32 %x, i32 %y) { ret i32 %sum3 } -; CHECK-LABEL: define internal i32 @simple_func1Tm(i32, i32, i32*) +; CHECK-LABEL: define internal i32 @simple_func1Tm(i32 %0, i32 %1, i32* %2) ; CHECK: %l = load i32, i32* %2 ; CHECK: ret @@ -79,7 +79,7 @@ define i32 @func3_of_3(i32 %x) { ret i32 %sum3 } -; CHECK-LABEL: define internal i32 @func1_of_3Tm(i32, i32*, i32*, void (i32)*) +; CHECK-LABEL: define internal i32 @func1_of_3Tm(i32 %0, i32* %1, i32* %2, void (i32)* %3) ; CHECK: %l1 = load i32, i32* %1 ; CHECK: %l2 = load i32, i32* %2 ; CHECK: store i32 %sum2, i32* %1 @@ -114,7 +114,7 @@ define void @sret_func2(i32* sret %p, i32 %x, i32 %y) { ret void } -; CHECK-LABEL: define internal void @sret_func1Tm(i32* sret, i32, i32, i32*) +; CHECK-LABEL: define internal void @sret_func1Tm(i32* sret %0, i32 %1, i32 %2, i32* %3) ; CHECK: %l = load i32, i32* %3, align 4 ; CHECK: store i32 %sum2, i32* %0 ; CHECK: ret @@ -174,7 +174,7 @@ define i32 @func3_merged_with1(i32 %x) { ret i32 %sum5 } -; CHECK-LABEL: define internal i32 @func1_merged_with3Tm(i32, i32*) +; CHECK-LABEL: define internal i32 @func1_merged_with3Tm(i32 %0, i32* %1) ; CHECK: load i32, i32* %1, align 4 ; CHECK: load i32, i32* @g2, align 4 ; CHECK: load i32, i32* @g3, align 4 @@ -263,7 +263,7 @@ define i32 @Function3_merged_with_1(i32 %x) { ret i32 %c } -; CHECK-LABEL: define internal i32 @Function1_merged_with_3Tm(i32, i32*) +; CHECK-LABEL: define internal i32 @Function1_merged_with_3Tm(i32 %0, i32* %1) ; CHECK: load ; CHECK: load ; CHECK: load @@ -320,7 +320,7 @@ define fastcc i32 @callee1_b(i32 %x, i32 %y) { ret i32 %sum3 } -; CHECK-LABEL: define internal fastcc i32 @callee1_aTm(i32, i32, i32*) +; CHECK-LABEL: define internal fastcc i32 @callee1_aTm(i32 %0, i32 %1, i32* %2) ; CHECK: call i32 @callee2_aTm(i32 %sum2, i32 %1, i32* %2) ; CHECK: ret @@ -364,7 +364,7 @@ define i32 @caller_b(i32 %x, i32 %y) { ret i32 %sum3 } -; CHECK-LABEL: define internal i32 @caller_aTm(i32, i32, i32*) +; CHECK-LABEL: define internal i32 @caller_aTm(i32 %0, i32 %1, i32* %2) ; CHECK: call fastcc i32 @callee1_aTm(i32 %sum2, i32 %1, i32* %2) ; CHECK: ret @@ -372,7 +372,7 @@ define i32 @caller_b(i32 %x, i32 %y) { ; Ensure that we do not merge functions that are identical with the ; exception of the order of the incoming blocks to a phi. -; CHECK-LABEL: define linkonce_odr hidden i1 @first(i2) +; CHECK-LABEL: define linkonce_odr hidden i1 @first(i2 %0) define linkonce_odr hidden i1 @first(i2) { entry: ; CHECK: switch i2 @@ -395,7 +395,7 @@ done: ret i1 %result } -; CHECK-LABEL: define linkonce_odr hidden i1 @second(i2) +; CHECK-LABEL: define linkonce_odr hidden i1 @second(i2 %0) define linkonce_odr hidden i1 @second(i2) { entry: ; CHECK: switch i2 @@ -449,7 +449,7 @@ bb1: bb2: ret void } -; CHECK-LABEL: define internal void @recursive1Tm(i32, i32, i32*, void (i32, i32)*) +; CHECK-LABEL: define internal void @recursive1Tm(i32 %0, i32 %1, i32* %2, void (i32, i32)* %3) ; CHECK: load i32, i32* %2 ; CHECK: call void %3(i32 %0, i32 %1) ; CHECK: ret void @@ -471,7 +471,7 @@ bb2: } ; CHECK-NOT: @not_really_recursive( -; CHECK-LABEL: define internal void @another_recursive_funcTm(i32, i32*, void (i32)*) +; CHECK-LABEL: define internal void @another_recursive_funcTm(i32 %0, i32* %1, void (i32)* %2) ; CHECK: store i32 %0, i32* %1 ; CHECK: call void %2(i32 %0) ; CHECK: ret void diff --git a/test/LLVMPasses/merge_func_coff.ll b/test/LLVMPasses/merge_func_coff.ll index 67c12f554e6b5..6935018dc9418 100644 --- a/test/LLVMPasses/merge_func_coff.ll +++ b/test/LLVMPasses/merge_func_coff.ll @@ -18,6 +18,6 @@ define dllexport i32 @h(i32 %x, i32 %y) { ret i32 %sum3 } -; CHECK-NOT: define internal dllexport i32 @fTm(i32, i32) -; CHECK-LABEL: define internal i32 @fTm(i32, i32) +; CHECK-NOT: define internal dllexport i32 @fTm(i32 %0, i32 %1) +; CHECK-LABEL: define internal i32 @fTm(i32 %0, i32 %1) diff --git a/test/LLVMPasses/missing_runtime_declarations.ll b/test/LLVMPasses/missing_runtime_declarations.ll index e9c08f8ef3309..ebd870f3c98ac 100644 --- a/test/LLVMPasses/missing_runtime_declarations.ll +++ b/test/LLVMPasses/missing_runtime_declarations.ll @@ -11,7 +11,7 @@ target triple = "x86_64-apple-macosx10.9" declare void @swift_bridgeObjectRelease(%a* nocapture) declare %a *@swift_bridgeObjectRetain(%a* nocapture) -; CHECK-LABEL: define void @testcase1(%a*) { +; CHECK-LABEL: define void @testcase1(%a* %0) { ; CHECK: entry: ; CHECK-NEXT: [[CAST:%.*]] = bitcast %a* %0 to %swift.bridge* ; CHECK-NEXT: call void @swift_bridgeObjectRelease_n(%swift.bridge* [[CAST]], i32 2) @@ -25,7 +25,7 @@ entry: declare void @user(%a*) -; CHECK-LABEL: define %a* @testcase2(%a*) { +; CHECK-LABEL: define %a* @testcase2(%a* %0) { ; CHECK: entry: ; CHECK-NEXT: [[CAST1:%.*]] = bitcast %a* %0 to %swift.bridge* ; CHECK-NEXT: [[RESULT:%.*]] ={{( tail)?}} call %swift.bridge* @swift_bridgeObjectRetain_n(%swift.bridge* [[CAST1]], i32 2) @@ -41,4 +41,4 @@ entry: call void @user(%a* %1) call void @user(%a* %2) ret %a* %2 -} \ No newline at end of file +} diff --git a/test/Misc/misc_diagnostics.swift b/test/Misc/misc_diagnostics.swift index c7d3e72f94738..4449414e68fa5 100644 --- a/test/Misc/misc_diagnostics.swift +++ b/test/Misc/misc_diagnostics.swift @@ -56,7 +56,9 @@ class A { } } -func retV() { return true } // expected-error {{unexpected non-void return value in void function}} +func retV() { return true } +// expected-error@-1 {{unexpected non-void return value in void function}} +// expected-note@-2 {{did you mean to add a return type?}} func retAI() -> Int { let a = [""] @@ -65,7 +67,9 @@ func retAI() -> Int { } func bad_return1() { - return 42 // expected-error {{unexpected non-void return value in void function}} + return 42 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } func bad_return2() -> (Int, Int) { @@ -74,7 +78,9 @@ func bad_return2() -> (Int, Int) { // QoI: Diagnostics for trying to return values from void functions func bad_return3(lhs: Int, rhs: Int) { - return lhs != 0 // expected-error {{unexpected non-void return value in void function}} + return lhs != 0 + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } class MyBadReturnClass { @@ -82,7 +88,9 @@ class MyBadReturnClass { } func ==(lhs:MyBadReturnClass, rhs:MyBadReturnClass) { - return MyBadReturnClass.intProperty == MyBadReturnClass.intProperty // expected-error{{unexpected non-void return value in void function}} + return MyBadReturnClass.intProperty == MyBadReturnClass.intProperty + // expected-error@-1 {{unexpected non-void return value in void function}} + // expected-note@-2 {{did you mean to add a return type?}} } @@ -156,4 +164,3 @@ func tuple_splat2(_ q : (a : Int, b : Int)) { func is_foreign(a: AnyObject) -> Bool { return a is CGColor // expected-warning {{'is' test is always true because 'CGColor' is a Core Foundation type}} } - diff --git a/test/Misc/tbi.sil b/test/Misc/tbi.sil index f22555d8c0aad..0fd2274c7ff40 100644 --- a/test/Misc/tbi.sil +++ b/test/Misc/tbi.sil @@ -19,13 +19,19 @@ // NO_TBI-LABEL: .globl _testTBI // NO_TBI: _testTBI +// NO_TBI-NEXT: stp +// NO_TBI-NEXT: mov // NO_TBI-NEXT: and // NO_TBI-NEXT: ldr +// NO_TBI-NEXT: ldp // NO_TBI-NEXT: ret // TBI-LABEL: .globl _testTBI // TBI: _testTBI: +// TBI-NEXT: stp +// TBI-NEXT: mov // TBI-NEXT: ldr +// TBI-NEXT: ldp // TBI-NEXT: ret sil_stage canonical diff --git a/test/ModuleInterface/Inputs/imports-clang-modules/B1.h b/test/ModuleInterface/Inputs/imports-clang-modules/B1.h index dd5431d93bef4..45a4a21327466 100644 --- a/test/ModuleInterface/Inputs/imports-clang-modules/B1.h +++ b/test/ModuleInterface/Inputs/imports-clang-modules/B1.h @@ -1 +1 @@ -void b1(void); \ No newline at end of file +void b1(void); diff --git a/test/ModuleInterface/Inputs/imports-clang-modules/B2.h b/test/ModuleInterface/Inputs/imports-clang-modules/B2.h index f30b5d7c33852..bc7fbc53b6c07 100644 --- a/test/ModuleInterface/Inputs/imports-clang-modules/B2.h +++ b/test/ModuleInterface/Inputs/imports-clang-modules/B2.h @@ -1 +1 @@ -void b2(void); \ No newline at end of file +void b2(void); diff --git a/test/ModuleInterface/Inputs/imports-clang-modules/B3.h b/test/ModuleInterface/Inputs/imports-clang-modules/B3.h index f30b5d7c33852..bc7fbc53b6c07 100644 --- a/test/ModuleInterface/Inputs/imports-clang-modules/B3.h +++ b/test/ModuleInterface/Inputs/imports-clang-modules/B3.h @@ -1 +1 @@ -void b2(void); \ No newline at end of file +void b2(void); diff --git a/test/Runtime/linux-fatal-backtrace.swift b/test/Runtime/linux-fatal-backtrace.swift index 92467a7b93c2f..7e84dc9719a62 100644 --- a/test/Runtime/linux-fatal-backtrace.swift +++ b/test/Runtime/linux-fatal-backtrace.swift @@ -4,7 +4,6 @@ // REQUIRES: executable_test // REQUIRES: OS=linux-gnu // REQUIRES: lldb -// REQUIRES: rdar59328972 // XFAIL: CPU=s390x // NOTE: not.py is used above instead of "not --crash" because %target-run diff --git a/test/SILGen/Inputs/usr/include/NonNilTest.h b/test/SILGen/Inputs/usr/include/NonNilTest.h index 8c0280f890902..a2b39a7e04da5 100644 --- a/test/SILGen/Inputs/usr/include/NonNilTest.h +++ b/test/SILGen/Inputs/usr/include/NonNilTest.h @@ -5,4 +5,4 @@ + (NonNilTest *)nonNilObject; @property NonNilTest *nonNilObjectProperty; @property (unsafe_unretained) NonNilTest *unownedNonNilObjectProperty; -@end \ No newline at end of file +@end diff --git a/test/SILGen/vtable_implementation_only.swift b/test/SILGen/vtable_implementation_only.swift new file mode 100644 index 0000000000000..a298c7e08bb13 --- /dev/null +++ b/test/SILGen/vtable_implementation_only.swift @@ -0,0 +1,36 @@ +// RUN: %empty-directory(%t) + +// For convenience, this file includes the three different "files" used in this +// test. It selects one with -DCoreDishwasher, -DDishwasherKit, or neither. + +// RUN: %target-swift-frontend -emit-module %s -DCoreDishwasher -module-name CoreDishwasher -o %t/CoreDishwasher -emit-module-path %t/CoreDishwasher.swiftmodule -I %t +// RUN: %target-swift-frontend -emit-module %s -DDishwasherKit -module-name DishwasherKit -o %t/DishwasherKit -emit-module-path %t/DishwasherKit.swiftmodule -enable-library-evolution -I %t +// RUN: %target-swift-frontend -emit-silgen -I %t %s + +#if CoreDishwasher + + public struct SpimsterWicket { + public init() {} + } + +#elseif DishwasherKit + + @_implementationOnly import CoreDishwasher + + open class Dishwasher { + public init() {} + + var wicket = SpimsterWicket() + + open var modelName: String { "Dishwasher" } + } + +#else + + import DishwasherKit + + open class FancyDishwasher: Dishwasher { + open override var modelName: String { "Fancy \(super.modelName)" } + } + +#endif diff --git a/test/SILOptimizer/eager_specialize.sil b/test/SILOptimizer/eager_specialize.sil index e020ad4660ee2..54f38697eea08 100644 --- a/test/SILOptimizer/eager_specialize.sil +++ b/test/SILOptimizer/eager_specialize.sil @@ -701,7 +701,7 @@ bb0(%0 : $*Self, %1 : $*Self, %2 : $@thick Self.Type): // Check that a specialization for _Trivial(32) uses direct loads and stores // instead of value witness functions to load and store the value of a generic type. -// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize18copyValueAndReturn_1sxx_xztlFxxxRlze31_lIetilr_Tp5"(i32* noalias nocapture sret, i32* noalias nocapture dereferenceable(4), i32* nocapture dereferenceable(4), %swift.type* %S) +// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize18copyValueAndReturn_1sxx_xztlFxxxRlze31_lIetilr_Tp5"(i32* noalias nocapture sret %0, i32* noalias nocapture dereferenceable(4) %1, i32* nocapture dereferenceable(4) %2, %swift.type* %S // CHECK-IRGEN: entry: // CHECK-IRGEN: %3 = load i32, i32* %2 // CHECK-IRGEN-NEXT: store i32 %3, i32* %0 @@ -710,7 +710,7 @@ bb0(%0 : $*Self, %1 : $*Self, %2 : $@thick Self.Type): // Check that a specialization for _Trivial(64) uses direct loads and stores // instead of value witness functions to load and store the value of a generic type. -// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize18copyValueAndReturn_1sxx_xztlFxxxRlze63_lIetilr_Tp5"(i64* noalias nocapture sret, i64* noalias nocapture dereferenceable(8), i64* nocapture dereferenceable(8), %swift.type* %S) +// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize18copyValueAndReturn_1sxx_xztlFxxxRlze63_lIetilr_Tp5"(i64* noalias nocapture sret %0, i64* noalias nocapture dereferenceable(8) %1, i64* nocapture dereferenceable(8) %2, %swift.type* %S // CHECK-IRGEN: entry: // CHECK-IRGEN: %3 = load i64, i64* %2 // CHECK-IRGEN-NEXT: store i64 %3, i64* %0 @@ -719,7 +719,7 @@ bb0(%0 : $*Self, %1 : $*Self, %2 : $@thick Self.Type): // Check that a specialization for _Trivial does not call the 'destroy' value witness, // because it is known that the object is Trivial, i.e. contains no references. -// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize19copyValueAndReturn2_1sxx_xztlFxxxRlzTlIetilr_Tp5"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.opaque* nocapture, %swift.type* %S) +// CHECK-IRGEN-LABEL: define linkonce_odr hidden swiftcc void @"$s16eager_specialize19copyValueAndReturn2_1sxx_xztlFxxxRlzTlIetilr_Tp5"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.opaque* nocapture %2, %swift.type* %S // CHECK-IRGEN-NEXT: entry: // CHECK-IRGEN: %3 = bitcast %swift.type* %S to i8*** // CHECK-IRGEN-NEXT: %4 = getelementptr inbounds i8**, i8*** %3, i{{.*}} -1 diff --git a/test/SILOptimizer/inline_thunk.swift b/test/SILOptimizer/inline_thunk.swift index aa10b607e4413..04efcbdde1b49 100644 --- a/test/SILOptimizer/inline_thunk.swift +++ b/test/SILOptimizer/inline_thunk.swift @@ -5,7 +5,7 @@ // 2. the witness thunk // Both should not inline the testit function and should set the noinline-attribute for llvm. -// CHECK-LABEL: define hidden swiftcc i32 @"{{.*}}testit{{.*}}F"(i32) +// CHECK-LABEL: define hidden swiftcc i32 @"{{.*}}testit{{.*}}F"(i32 %0) // CHECK: call swiftcc i32 @{{.*}}testit{{.*}}Tf{{.*}} #[[ATTR:[0-9]+]] // CHECK: ret diff --git a/test/Sanitizers/asan_recover.swift b/test/Sanitizers/asan_recover.swift index b65c977b68aeb..50191fbb1c56f 100644 --- a/test/Sanitizers/asan_recover.swift +++ b/test/Sanitizers/asan_recover.swift @@ -2,6 +2,9 @@ // REQUIRES: asan_runtime // UNSUPPORTED: windows +// TODO(rdar://problem/58702902) Re-enable on Linux once rdar://problem/58640751 is fixed. +// UNSUPPORTED: OS=linux-gnu + // Check with recovery instrumentation and runtime option to continue execution. // RUN: %target-swiftc_driver %s -target %sanitizers-target-triple -g -sanitize=address -sanitize-recover=address -import-objc-header %S/asan_interface.h -emit-ir -o %t.asan_recover.ll // RUN: %FileCheck -check-prefix=CHECK-IR -input-file=%t.asan_recover.ll %s diff --git a/test/lit.cfg b/test/lit.cfg index 7a820ec9f89b1..be06f74b79367 100644 --- a/test/lit.cfg +++ b/test/lit.cfg @@ -126,6 +126,10 @@ def get_simulator_command(run_os, run_cpu, sdk_path): else: lit_config.fatal("Unknown simulator OS %r" % run_os) +def get_lldb_python_path(lldb_build_root): + lldb_path = os.path.join(lldb_build_root, 'bin', 'lldb') + return subprocess.check_output([lldb_path, "-P"]).rstrip() + assert darwin_sdk_build_version_cmp("11A1", "12A1") < 0 assert darwin_sdk_build_version_cmp("12A1", "11A1") > 0 @@ -1780,10 +1784,8 @@ config.substitutions.append(('%import-libdispatch', getattr(config, 'import_libd if config.lldb_build_root != "": config.available_features.add('lldb') - # Note: using the same approach to locating the lib dir as in - # finishSwigPythonLLDB.py in the lldb repo - python_lib_dir = get_python_lib(True, False, config.lldb_build_root) - config.substitutions.append(('%lldb-python-path', python_lib_dir)) + lldb_python_path = get_lldb_python_path(config.lldb_build_root) + config.substitutions.append(('%lldb-python-path', lldb_python_path)) # Disable randomized hash seeding by default. Tests need to manually opt in to # random seeds by unsetting the SWIFT_DETERMINISTIC_HASHING environment diff --git a/test/multifile/require-layout-generic-arg-closure.swift b/test/multifile/require-layout-generic-arg-closure.swift index b81e7057d8f85..c579c448f726e 100644 --- a/test/multifile/require-layout-generic-arg-closure.swift +++ b/test/multifile/require-layout-generic-arg-closure.swift @@ -17,7 +17,7 @@ public func requestType2(x: T) { requestTypeThrough(closure: { x in print(x) }, arg: x) } -// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor*, i8**, i8*) +// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // FILE2: [[T_ADDR:%.*]] = bitcast i8** %1 to %swift.type** // FILE2: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]] // FILE2: [[CLASSMETADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata diff --git a/test/multifile/require-layout-generic-arg-subscript.swift b/test/multifile/require-layout-generic-arg-subscript.swift index a816e9d9ac3de..e2fb435394d9e 100644 --- a/test/multifile/require-layout-generic-arg-subscript.swift +++ b/test/multifile/require-layout-generic-arg-subscript.swift @@ -5,7 +5,7 @@ // The offset of the typemetadata in the class typemetadata must match. -// FILE1: define hidden swiftcc i64 @"$s4test12AccessorTestCySiAA3SubCyxGcluig"(%T4test3SubC*, %T4test12AccessorTestC* swiftself) +// FILE1: define hidden swiftcc i64 @"$s4test12AccessorTestCySiAA3SubCyxGcluig"(%T4test3SubC* %0, %T4test12AccessorTestC* swiftself %1) // FILE1: [[T1:%.*]] = bitcast %T4test3SubC* %0 to %swift.type** // FILE1: [[TYPEMETADATA:%.*]] = load %swift.type*, %swift.type** [[T1]] // FILE1: [[T2:%.*]] = bitcast %swift.type* [[TYPEMETADATA]] to %swift.type** @@ -21,7 +21,7 @@ public class AccessorTest { } } -// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor*, i8**, i8*) +// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // FILE2: [[T_ADDR:%.*]] = bitcast i8** %1 to %swift.type** // FILE2: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]] // FILE2: [[CLASSMETADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata diff --git a/test/multifile/require-layout-generic-arg.swift b/test/multifile/require-layout-generic-arg.swift index 38507eba30557..d35c9ea688ea6 100644 --- a/test/multifile/require-layout-generic-arg.swift +++ b/test/multifile/require-layout-generic-arg.swift @@ -5,7 +5,7 @@ // The offset of the typemetadata in the class typemetadata must match. -// FILE1-LABEL: define{{.*}} swiftcc void @"$s4test11requestTypeyyAA3SubCyxGlF"(%T4test3SubC*) +// FILE1-LABEL: define{{.*}} swiftcc void @"$s4test11requestTypeyyAA3SubCyxGlF"(%T4test3SubC* %0) // FILE1: [[T1:%.*]] = bitcast %T4test3SubC* %0 to %swift.type** // FILE1: [[TYPEMETADATA:%.*]] = load %swift.type*, %swift.type** [[T1]] // FILE1: [[T2:%.*]] = bitcast %swift.type* [[TYPEMETADATA]] to %swift.type** @@ -15,7 +15,7 @@ public func requestType(_ c: Sub) { print(T.self) } -// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor*, i8**, i8*) +// FILE2-LABEL: define internal %swift.type* @"$s4test3SubCMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) // FILE2: [[T_ADDR:%.*]] = bitcast i8** %1 to %swift.type** // FILE2: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]] // FILE2: [[CLASSMETADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata diff --git a/test/sil-llvm-gen/alloc.sil b/test/sil-llvm-gen/alloc.sil index 362e3def70207..93fc4900f6c66 100644 --- a/test/sil-llvm-gen/alloc.sil +++ b/test/sil-llvm-gen/alloc.sil @@ -19,6 +19,6 @@ struct Huge { var unalign: Builtin.Int8 } -// CHECK: define linkonce_odr hidden i8* @__swift_memcpy4097_8(i8*, i8*, %swift.type*) +// CHECK: define linkonce_odr hidden i8* @__swift_memcpy4097_8(i8* %0, i8* %1, %swift.type* %2) // CHECK: call void @llvm.memcpy.p0i8.p0i8.{{(i64|i32)}}(i8* align 8 %0, i8* align 8 %1, {{(i64|i32)}} 4097, i1 false) // CHECK: ret i8* %0 diff --git a/test/type/opaque.swift b/test/type/opaque.swift index c1b73be63bbe2..9d0b7bdb95e6b 100644 --- a/test/type/opaque.swift +++ b/test/type/opaque.swift @@ -270,10 +270,10 @@ func associatedTypeIdentity() { sameType(cr, c.r_out()) sameType(dr, d.r_out()) - sameType(cr, dr) // expected-error{{}} expected-note {{}} + sameType(cr, dr) // expected-error {{cannot convert value of type '(some opaque.R).S' (associated type of protocol 'R') to expected argument type '(some opaque.R).S' (associated type of protocol 'R')}} sameType(gary(candace()).r_out(), gary(candace()).r_out()) sameType(gary(doug()).r_out(), gary(doug()).r_out()) - sameType(gary(doug()).r_out(), gary(candace()).r_out()) // expected-error{{}} expected-note {{}} + sameType(gary(doug()).r_out(), gary(candace()).r_out()) // expected-error {{cannot convert value of type 'some R' (result of 'candace()') to expected argument type 'some R' (result of 'doug()')}} } func redeclaration() -> some P { return 0 } // expected-note 2{{previously declared}} diff --git a/tools/SourceKit/lib/SwiftLang/CodeCompletion.h b/tools/SourceKit/lib/SwiftLang/CodeCompletion.h index 681340f609a80..21a9686c24eb8 100644 --- a/tools/SourceKit/lib/SwiftLang/CodeCompletion.h +++ b/tools/SourceKit/lib/SwiftLang/CodeCompletion.h @@ -17,6 +17,7 @@ #include "swift/IDE/CodeCompletion.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/Optional.h" +#include "llvm/ADT/StringMap.h" namespace SourceKit { namespace CodeCompletion { diff --git a/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp b/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp index 8a4237f0d4449..ebdd64b794c54 100644 --- a/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp +++ b/tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp @@ -396,14 +396,14 @@ static StringRef copyString(llvm::BumpPtrAllocator &allocator, StringRef str) { } static std::unique_ptr make_group(StringRef name) { - auto g = llvm::make_unique(); + auto g = std::make_unique(); g->name = name; g->description = name; return g; } static std::unique_ptr make_result(Completion *result) { - auto r = llvm::make_unique(result); + auto r = std::make_unique(result); r->name = result->getName(); r->description = result->getDescription(); return r; diff --git a/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp b/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp index 006f871fa4f1c..bee79f01cfaa4 100644 --- a/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp +++ b/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp @@ -1291,9 +1291,9 @@ SwiftCompletionCache::~SwiftCompletionCache() {} void SwiftLangSupport::codeCompleteCacheOnDisk(StringRef path) { ThreadSafeRefCntPtr newCache(new SwiftCompletionCache); - newCache->onDisk = llvm::make_unique(path); + newCache->onDisk = std::make_unique(path); newCache->inMemory = - llvm::make_unique(newCache->onDisk.get()); + std::make_unique(newCache->onDisk.get()); CCCache = newCache; // replace the old cache. } diff --git a/tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp b/tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp index 503d9f303bcde..6ae23afd709ce 100644 --- a/tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp +++ b/tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp @@ -273,10 +273,10 @@ SwiftLangSupport::SwiftLangSupport(SourceKit::Context &SKCtx) CompletionInst = std::make_unique(); // By default, just use the in-memory cache. - CCCache->inMemory = llvm::make_unique(); + CCCache->inMemory = std::make_unique(); // Provide a default file system provider. - setFileSystemProvider("in-memory-vfs", llvm::make_unique()); + setFileSystemProvider("in-memory-vfs", std::make_unique()); } SwiftLangSupport::~SwiftLangSupport() { diff --git a/tools/SourceKit/tools/sourcekitd-repl/sourcekitd-repl.cpp b/tools/SourceKit/tools/sourcekitd-repl/sourcekitd-repl.cpp index 5c0c1340c0a00..e7f600bc1d074 100644 --- a/tools/SourceKit/tools/sourcekitd-repl/sourcekitd-repl.cpp +++ b/tools/SourceKit/tools/sourcekitd-repl/sourcekitd-repl.cpp @@ -353,9 +353,8 @@ class REPLInput { PromptString.clear(); if (ShowColors) { - const char *colorCode = - llvm::sys::Process::OutputColor(llvm::raw_ostream::YELLOW, - false, false); + const char *colorCode = llvm::sys::Process::OutputColor( + static_cast(llvm::raw_ostream::YELLOW), false, false); if (colorCode) appendEscapeSequence(PromptString, colorCode); } diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp index 0283b48ae67a5..4d57be4849924 100644 --- a/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp +++ b/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp @@ -406,7 +406,7 @@ static Optional getVFSOptions(RequestDict &Req) { std::unique_ptr options; if (auto dict = Req.getDictionary(KeyVFSOptions)) { - options = llvm::make_unique(*dict); + options = std::make_unique(*dict); } return VFSOptions{name->str(), std::move(options)}; @@ -2030,7 +2030,7 @@ static sourcekitd_response_t codeCompleteOpen(StringRef Name, std::unique_ptr options; std::vector filterRules; if (optionsDict) { - options = llvm::make_unique(*optionsDict); + options = std::make_unique(*optionsDict); bool failed = false; optionsDict->dictionaryArrayApply(KeyFilterRules, [&](RequestDict dict) { FilterRule rule; @@ -2125,7 +2125,7 @@ codeCompleteUpdate(StringRef name, int64_t offset, SKGroupedCodeCompletionConsumer CCC(RespBuilder); std::unique_ptr options; if (optionsDict) - options = llvm::make_unique(*optionsDict); + options = std::make_unique(*optionsDict); LangSupport &Lang = getGlobalContext().getSwiftLangSupport(); Lang.codeCompleteUpdate(name, offset, options.get(), CCC); return CCC.createResponse(); diff --git a/tools/driver/autolink_extract_main.cpp b/tools/driver/autolink_extract_main.cpp index f805714c30eb2..d025564f8e0de 100644 --- a/tools/driver/autolink_extract_main.cpp +++ b/tools/driver/autolink_extract_main.cpp @@ -113,8 +113,12 @@ extractLinkerFlagsFromObjectFile(const llvm::object::ObjectFile *ObjectFile, CompilerInstance &Instance) { // Search for the section we hold autolink entries in for (auto &Section : ObjectFile->sections()) { - llvm::StringRef SectionName; - Section.getName(SectionName); + llvm::Expected SectionNameOrErr = Section.getName(); + if (!SectionNameOrErr) { + llvm::consumeError(SectionNameOrErr.takeError()); + continue; + } + llvm::StringRef SectionName = *SectionNameOrErr; if (SectionName == ".swift1_autolink_entries") { llvm::Expected SectionData = Section.getContents(); if (!SectionData) { diff --git a/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp b/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp index 006ca9fa6e67b..ecb6f8cb9e450 100644 --- a/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp +++ b/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp @@ -293,7 +293,7 @@ swiftparse_client_node_t SynParser::parse(const char *source) { PU.getParser().State->PerformConditionEvaluation = false; std::unique_ptr pConsumer; if (DiagHandler) { - pConsumer = llvm::make_unique(*this, bufID); + pConsumer = std::make_unique(*this, bufID); PU.getDiagnosticEngine().addConsumer(*pConsumer); } return PU.parse(); diff --git a/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp b/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp index ce0b3261257d0..e3dc90678712f 100644 --- a/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp +++ b/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp @@ -167,8 +167,12 @@ collectASTModules(llvm::cl::list &InputNames, } for (auto &Section : Obj->sections()) { - llvm::StringRef Name; - Section.getName(Name); + llvm::Expected NameOrErr = Section.getName(); + if (!NameOrErr) { + llvm::consumeError(NameOrErr.takeError()); + continue; + } + llvm::StringRef Name = *NameOrErr; if ((MachO && Name == swift::MachOASTSectionName) || (ELF && Name == swift::ELFASTSectionName) || (COFF && Name == swift::COFFASTSectionName)) { diff --git a/tools/sil-opt/SILOpt.cpp b/tools/sil-opt/SILOpt.cpp index c584a950a1ce2..f9b76d1c1331e 100644 --- a/tools/sil-opt/SILOpt.cpp +++ b/tools/sil-opt/SILOpt.cpp @@ -431,13 +431,13 @@ int main(int argc, char **argv) { std::unique_ptr OptRecordFile; if (RemarksFilename != "") { std::error_code EC; - OptRecordFile = llvm::make_unique( + OptRecordFile = std::make_unique( RemarksFilename, EC, llvm::sys::fs::F_None); if (EC) { llvm::errs() << EC.message() << '\n'; return 1; } - auto Stream = llvm::make_unique(*OptRecordFile, + auto Stream = std::make_unique(*OptRecordFile, &CI.getSourceMgr()); CI.getSILModule()->setOptRecordStream(std::move(Stream), std::move(OptRecordFile)); diff --git a/tools/swift-api-digester/swift-api-digester.cpp b/tools/swift-api-digester/swift-api-digester.cpp index 6253f69a9e8df..4a1837bc199c3 100644 --- a/tools/swift-api-digester/swift-api-digester.cpp +++ b/tools/swift-api-digester/swift-api-digester.cpp @@ -2270,8 +2270,8 @@ static int diagnoseModuleChange(SDKContext &Ctx, SDKNodeRoot *LeftModule, OS = FileOS.get(); } std::unique_ptr pConsumer = options::CompilerStyleDiags ? - llvm::make_unique(): - llvm::make_unique(true, *OS); + std::make_unique(): + std::make_unique(true, *OS); Ctx.addDiagConsumer(*pConsumer); Ctx.setCommonVersion(std::min(LeftModule->getJsonFormatVersion(), @@ -2345,8 +2345,8 @@ static int generateMigrationScript(StringRef LeftPath, StringRef RightPath, } llvm::errs() << "Diffing: " << LeftPath << " and " << RightPath << "\n"; std::unique_ptr pConsumer = options::CompilerStyleDiags ? - llvm::make_unique(): - llvm::make_unique(false); + std::make_unique(): + std::make_unique(false); SDKContext Ctx(Opts); Ctx.addDiagConsumer(*pConsumer); diff --git a/tools/swift-ide-test/swift-ide-test.cpp b/tools/swift-ide-test/swift-ide-test.cpp index 995eaaaab5eef..f09d37aa6251e 100644 --- a/tools/swift-ide-test/swift-ide-test.cpp +++ b/tools/swift-ide-test/swift-ide-test.cpp @@ -834,7 +834,7 @@ static int doCodeCompletion(const CompilerInvocation &InitInvok, bool CodeCompletionComments) { std::unique_ptr OnDiskCache; if (!options::CompletionCachePath.empty()) { - OnDiskCache = llvm::make_unique( + OnDiskCache = std::make_unique( options::CompletionCachePath); } ide::CodeCompletionCache CompletionCache(OnDiskCache.get()); @@ -1043,8 +1043,8 @@ class PrintSyntaxColorWalker : public ide::SyntaxModelWalker { } if (Begin) { - if (const char *CStr = - llvm::sys::Process::OutputColor(Col, false, false)) { + if (const char *CStr = llvm::sys::Process::OutputColor( + static_cast(Col), false, false)) { OS << CStr; } } else { @@ -1596,8 +1596,8 @@ class AnnotationPrinter : public SourceEntityWalker { Col = llvm::raw_ostream::CYAN; break; } - if (const char *CStr = - llvm::sys::Process::OutputColor(Col, false, false)) { + if (const char *CStr = llvm::sys::Process::OutputColor( + static_cast(Col), false, false)) { OS << CStr; } OS << Text; diff --git a/tools/swift-reflection-dump/swift-reflection-dump.cpp b/tools/swift-reflection-dump/swift-reflection-dump.cpp index 747713a61cbfa..69dc1120f7e11 100644 --- a/tools/swift-reflection-dump/swift-reflection-dump.cpp +++ b/tools/swift-reflection-dump/swift-reflection-dump.cpp @@ -565,7 +565,7 @@ static int doDumpReflectionSections(ArrayRef BinaryFilenames, const ObjectFile *O = dyn_cast(BinaryFile); if (!O) { auto Universal = cast(BinaryFile); - ObjectOwner = unwrap(Universal->getObjectForArch(Arch)); + ObjectOwner = unwrap(Universal->getMachOObjectForArch(Arch)); O = ObjectOwner.get(); } diff --git a/tools/swift-syntax-test/swift-syntax-test.cpp b/tools/swift-syntax-test/swift-syntax-test.cpp index 2ef9c4b9e1075..975dcf5d71dc1 100644 --- a/tools/swift-syntax-test/swift-syntax-test.cpp +++ b/tools/swift-syntax-test/swift-syntax-test.cpp @@ -790,7 +790,7 @@ int doDeserializeRawTree(const char *MainExecutablePath, auto Buffer = llvm::MemoryBuffer::getFile(InputFile); std::error_code errorCode; - auto os = llvm::make_unique( + auto os = std::make_unique( OutputFileName, errorCode, llvm::sys::fs::F_None); swift::json::SyntaxDeserializer deserializer(llvm::MemoryBufferRef(*(Buffer.get()))); deserializer.getSourceFileSyntax()->print(*os); diff --git a/unittests/AST/DiagnosticConsumerTests.cpp b/unittests/AST/DiagnosticConsumerTests.cpp index 77032b705a935..190bcd53daf67 100644 --- a/unittests/AST/DiagnosticConsumerTests.cpp +++ b/unittests/AST/DiagnosticConsumerTests.cpp @@ -65,9 +65,9 @@ TEST(FileSpecificDiagnosticConsumer, SubconsumersFinishInOrder) { (void)sourceMgr.addMemBufferCopy("abcde", "A"); (void)sourceMgr.addMemBufferCopy("vwxyz", "B"); - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, None); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), None); SmallVector consumers; @@ -85,9 +85,9 @@ TEST(FileSpecificDiagnosticConsumer, InvalidLocDiagsGoToEveryConsumer) { (void)sourceMgr.addMemBufferCopy("vwxyz", "B"); ExpectedDiagnostic expected[] = { Located("dummy", SourceLoc()) }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expected); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expected); SmallVector consumers; @@ -127,9 +127,9 @@ TEST(FileSpecificDiagnosticConsumer, ErrorsWithLocationsGoToExpectedConsumers) { {"back", backOfB} }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerB = llvm::make_unique( + auto consumerB = std::make_unique( consumerA.get(), expectedB); SmallVector consumers; @@ -184,9 +184,9 @@ TEST(FileSpecificDiagnosticConsumer, {"back", backOfB} }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; @@ -232,9 +232,9 @@ TEST(FileSpecificDiagnosticConsumer, WarningsAndRemarksAreTreatedLikeErrors) { {"remark", frontOfB}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; @@ -289,9 +289,9 @@ TEST(FileSpecificDiagnosticConsumer, NotesAreAttachedToErrors) { {"note", backOfB}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; @@ -352,9 +352,9 @@ TEST(FileSpecificDiagnosticConsumer, NotesAreAttachedToWarningsAndRemarks) { {"note", backOfB}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; @@ -415,9 +415,9 @@ TEST(FileSpecificDiagnosticConsumer, NotesAreAttachedToErrorsEvenAcrossFiles) { {"note", backOfB}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerB = llvm::make_unique( + auto consumerB = std::make_unique( consumerA.get(), expectedB); SmallVector consumers; @@ -479,9 +479,9 @@ TEST(FileSpecificDiagnosticConsumer, {"note", backOfB}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; @@ -535,9 +535,9 @@ TEST(FileSpecificDiagnosticConsumer, {"note", SourceLoc()}, }; - auto consumerA = llvm::make_unique( + auto consumerA = std::make_unique( nullptr, expectedA); - auto consumerUnaffiliated = llvm::make_unique( + auto consumerUnaffiliated = std::make_unique( consumerA.get(), expectedUnaffiliated); SmallVector consumers; diff --git a/utils/build-script-impl b/utils/build-script-impl index 255ac4beb3844..296251e040296 100755 --- a/utils/build-script-impl +++ b/utils/build-script-impl @@ -101,6 +101,7 @@ KNOWN_SETTINGS=( darwin-deployment-version-tvos "9.0" "minimum deployment target version for tvOS" darwin-deployment-version-watchos "2.0" "minimum deployment target version for watchOS" darwin-install-extract-symbols "" "whether to extract symbols with dsymutil during installations" + darwin-install-extract-symbols-use-just-built-dsymutil "1" "whether we should extract symbols using the just built dsymutil" darwin-overlay-target "" "single overlay target to build, dependencies are computed later" darwin-sdk-deployment-targets "xctest-ios-8.0" "semicolon-separated list of triples like 'fookit-ios-9.0;barkit-watchos-9.0'" darwin-stdlib-install-name-dir "" "the directory of the install_name for standard library dylibs" @@ -866,6 +867,10 @@ function xcrun_find_tool() { xcrun --sdk macosx --toolchain "${DARWIN_XCRUN_TOOLCHAIN}" --find "$@" } +function find_just_built_local_host_llvm_tool() { + find $(build_directory "${LOCAL_HOST}" llvm) -name "$1" -type f -print +} + function not() { if [[ ! "$1" ]] ; then echo 1 @@ -1828,6 +1833,11 @@ for host in "${ALL_HOSTS[@]}"; do -DLLVM_DIR:PATH=${llvm_build_dir}/lib/cmake/llvm -DClang_DIR:PATH=${llvm_build_dir}/lib/cmake/clang -DSwift_DIR:PATH=${swift_build_dir}/lib/cmake/swift + -DLLDB_ENABLE_CURSES=ON + -DLLDB_ENABLE_LIBEDIT=ON + -DLLDB_ENABLE_PYTHON=ON + -DLLDB_ENABLE_LZMA=OFF + -DLLDB_ENABLE_LUA=OFF -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_IS_BUILDBOT_BUILD:BOOL="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" @@ -2354,7 +2364,7 @@ for host in "${ALL_HOSTS[@]}"; do call ${NINJA_BIN} -j ${BUILD_JOBS} lldb-test-deps with_pushd ${results_dir} \ call "${llvm_build_dir}/bin/llvm-lit" \ - "${lldb_build_dir}/lit" \ + "${lldb_build_dir}/test" \ ${LLVM_LIT_ARGS} if [[ -x "${LLDB_TEST_SWIFT_COMPATIBILITY}" ]] ; then @@ -2363,7 +2373,7 @@ for host in "${ALL_HOSTS[@]}"; do DOTEST_ARGS="-G swift-history --swift-compiler \"${LLDB_TEST_SWIFT_COMPATIBILITY}\"" with_pushd ${results_dir} \ call "${llvm_build_dir}/bin/llvm-lit" \ - "${lldb_build_dir}/lit" \ + "${lldb_build_dir}/test" \ ${LLVM_LIT_ARGS} \ --param dotest-args="${DOTEST_ARGS}" \ --filter=compat @@ -2841,6 +2851,13 @@ for host in "${ALL_HOSTS[@]}"; do (cd "${CURRENT_INSTALL_DIR}" && find ./"${CURRENT_PREFIX}" -perm -0111 -type f -print | cpio --insecure -pdm "${INSTALL_SYMROOT}") + dsymutil_path= + if [[ -n "${DARWIN_INSTALL_EXTRACT_SYMBOLS_USE_JUST_BUILT_DSYMUTIL}" ]]; then + dsymutil_path=$(find_just_built_local_host_llvm_tool dsymutil) + else + dsymutil_path=$(xcrun_find_tool dsymutil) + fi + # Run dsymutil on executables and shared libraries. # # Exclude shell scripts and static archives. @@ -2848,7 +2865,7 @@ for host in "${ALL_HOSTS[@]}"; do find ./"${CURRENT_PREFIX}" -perm -0111 -type f -print | \ grep -v '.py$' | \ grep -v '.a$' | \ - xargs -n 1 -P ${BUILD_JOBS} $(xcrun_find_tool dsymutil)) + xargs -n 1 -P ${BUILD_JOBS} ${dsymutil_path}) # Strip executables, shared libraries and static libraries in # `host_install_destdir`. diff --git a/validation-test/Reflection/existentials.swift b/validation-test/Reflection/existentials.swift index a1f131c38ab87..e9955a0eb05da 100644 --- a/validation-test/Reflection/existentials.swift +++ b/validation-test/Reflection/existentials.swift @@ -5,6 +5,7 @@ // REQUIRES: objc_interop // REQUIRES: executable_test +// UNSUPPORTED: use_os_stdlib /* This file pokes at the swift_reflection_projectExistential API @@ -67,6 +68,7 @@ reflect(any: mc) // CHECK-64-NEXT: (struct Swift.Int)) // CHECK-64: Type info: // CHECK-64: (reference kind=strong refcounting=native) +// CHECK-64: Mangled name: $s12existentials7MyClassCyS2iG // CHECK-32: Reflecting an existential. // CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}} @@ -76,6 +78,7 @@ reflect(any: mc) // CHECK-32-NEXT: (struct Swift.Int)) // CHECK-32: Type info: // CHECK-32: (reference kind=strong refcounting=native) +// CHECK-32: Mangled name: $s12existentials7MyClassCyS2iG // This value fits in the 3-word buffer in the container. var smallStruct = MyStruct(x: 1, y: 2, z: 3) @@ -103,6 +106,7 @@ reflect(any: smallStruct) // CHECK-64-NEXT: (struct size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-64-NEXT: (field name=_value offset=0 // CHECK-64-NEXT: (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1))))) +// CHECK-64-NEXT: Mangled name: $s12existentials8MyStructVyS3iG // CHECK-32: Reflecting an existential. // CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}} @@ -126,6 +130,7 @@ reflect(any: smallStruct) // CHECK-32-NEXT: (struct size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-32-NEXT: (field name=_value offset=0 // CHECK-32-NEXT: (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1))))) +// CHECK-32-NEXT: Mangled name: $s12existentials8MyStructVyS3iG // This value will be copied into a heap buffer, with a // pointer to it in the existential. @@ -192,6 +197,7 @@ reflect(any: largeStruct) // CHECK-64-NEXT: (struct size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-64-NEXT: (field name=_value offset=0 // CHECK-64-NEXT: (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1))))))) +// CHECK-64-NEXT: Mangled name: $s12existentials8MyStructVySi_S2itSi_S2itSi_S2itG // CHECK-32: Reflecting an existential. // CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}} @@ -253,6 +259,41 @@ reflect(any: largeStruct) // CHECK-32-NEXT: (struct size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-32-NEXT: (field name=_value offset=0 // CHECK-32-NEXT: (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1))))))) +// CHECK-32-NEXT: Mangled name: $s12existentials8MyStructVySi_S2itSi_S2itSi_S2itG + +// Function type: +reflect(any: {largeStruct}) +// CHECK-64: Mangled name: $s12existentials8MyStructVySi_S2itSi_S2itSi_S2itGyc +// CHECK-32: Mangled name: $s12existentials8MyStructVySi_S2itSi_S2itSi_S2itGyc + +// Protocol composition: +protocol P {} +protocol Q {} +protocol Composition : P, Q {} +struct S : Composition {} +func getComposition() -> P & Q { return S() } +reflect(any: getComposition()) +// CHECK-64: Mangled name: $s12existentials1P_AA1Qp +// CHECK-32: Mangled name: $s12existentials1P_AA1Qp + +// Metatype: +reflect(any: Int.self) +// CHECK-64: Mangled name: $sSim +// CHECK-32: Mangled name: $sSim + +protocol WithType { + associatedtype T + func f() -> T +} +struct S1 : WithType { + typealias T = Int + func f() -> Int { return 0 } +} +func getWithType(_ t: T) where T: WithType { + reflect(any: T.self) +} +getWithType(S1()) + var he = HasError(singleError: MyError(), errorInComposition: MyError(), customError: MyCustomError(), customErrorInComposition: MyCustomError()) reflect(any: he) @@ -290,6 +331,7 @@ reflect(any: he) // CHECK-64-NEXT: (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=1 bitwise_takable=1)) // CHECK-64-NEXT: (field name=wtable offset=40 // CHECK-64-NEXT: (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=1 bitwise_takable=1))))) +// CHECK-64-NEXT: Mangled name: $s12existentials8HasErrorV // CHECK-32: Reflecting an existential. // CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}} @@ -324,6 +366,7 @@ reflect(any: he) // CHECK-32-NEXT: (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=1 bitwise_takable=1)) // CHECK-32-NEXT: (field name=wtable offset=20 // CHECK-32-NEXT: (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=1 bitwise_takable=1))))) +// CHECK-32-NEXT: Mangled name: $s12existentials8HasErrorV reflect(error: MyError()) @@ -338,6 +381,7 @@ reflect(error: MyError()) // CHECK-64-NEXT: (struct size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-64-NEXT: (field name=_value offset=0 // CHECK-64-NEXT: (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=0 bitwise_takable=1))))) +// CHECK-64-NEXT: Mangled name: $s12existentials7MyErrorV // CHECK-32: Reflecting an error existential. // CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}} @@ -350,5 +394,6 @@ reflect(error: MyError()) // CHECK-32-NEXT: (struct size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1 // CHECK-32-NEXT: (field name=_value offset=0 // CHECK-32-NEXT: (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=0 bitwise_takable=1))))) +// CHECK-32-NEXT: Mangled name: $s12existentials7MyErrorV doneReflecting() diff --git a/validation-test/Reflection/existentials_objc.swift b/validation-test/Reflection/existentials_objc.swift index 143c07ed2f1e0..b631fe61061c8 100644 --- a/validation-test/Reflection/existentials_objc.swift +++ b/validation-test/Reflection/existentials_objc.swift @@ -27,6 +27,11 @@ if #available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) { // CHECK: Type reference: // CHECK: (objective_c_class name=__NSCFNumber) reflect(object: NSNumber(123)) + + // Objective-C protocol: + // CHECK: Type info: + // CHECK: $sSo9NSCopying_Xl + reflect(any: { () -> NSCopying in NSString("abc") }()) } else { // The Swift 5.0 libraries don't support this test. class SkipTheTest {}

.Type): public class D { } -// CHECK: define void @testDynamicSelfMetatype(i8*, i8*) +// CHECK: define void @testDynamicSelfMetatype(i8* %0, i8* %1) // CHECK: [[T0:%.*]] = bitcast {{.*}} %0 // CHECK: [[T1:%.*]] = bitcast {{.*}} [[T0]] // CHECK: [[TYPE:%.*]] = load {{.*}} [[T1]] diff --git a/test/IRGen/objc_generic_protocol_conformance.swift b/test/IRGen/objc_generic_protocol_conformance.swift index 6acbe6fb73e16..cbfd4c5b68349 100644 --- a/test/IRGen/objc_generic_protocol_conformance.swift +++ b/test/IRGen/objc_generic_protocol_conformance.swift @@ -8,4 +8,4 @@ protocol P { extension Foo: P {} // SIL-LABEL: sil private [transparent] [thunk] [ossa] @$sSo3FooCyxG33objc_generic_protocol_conformance1PA2dEP3fooyyFTW {{.*}} @pseudogeneric -// IR-LABEL: define internal swiftcc void @"$sSo3FooCyxG33objc_generic_protocol_conformance1PA2dEP3fooyyFTW"(%TSo3FooC** noalias nocapture swiftself dereferenceable({{4|8}}), %swift.type*{{( %Self)?}}, i8**{{( %SelfWitnessTable)?}}) +// IR-LABEL: define internal swiftcc void @"$sSo3FooCyxG33objc_generic_protocol_conformance1PA2dEP3fooyyFTW"(%TSo3FooC** noalias nocapture swiftself dereferenceable({{4|8}}) %0, %swift.type*{{( %Self)?}}, i8**{{( %SelfWitnessTable)?}}) diff --git a/test/IRGen/objc_ns_enum.swift b/test/IRGen/objc_ns_enum.swift index 113341aa5d3c4..26ad01f27a8dc 100644 --- a/test/IRGen/objc_ns_enum.swift +++ b/test/IRGen/objc_ns_enum.swift @@ -90,7 +90,7 @@ func test_enum_without_name_Equatable(_ obj: TestThatEnumType) -> Bool { func use_metadata(_ t:T){} use_metadata(NSRuncingOptions.mince) -// CHECK-LABEL: define linkonce_odr hidden swiftcc %swift.metadata_response @"$sSo16NSRuncingOptionsVMa"(i64) +// CHECK-LABEL: define linkonce_odr hidden swiftcc %swift.metadata_response @"$sSo16NSRuncingOptionsVMa"(i64 %0) // CHECK: call swiftcc %swift.metadata_response @swift_getForeignTypeMetadata([[INT]] %0, // CHECK-SAME: @"$sSo16NSRuncingOptionsVMf" // CHECK-SAME: [[NOUNWIND_READNONE:#[0-9]+]] @@ -105,7 +105,7 @@ func objc_enum_inject() -> ExportedToObjC { return .Foo } -// CHECK-LABEL: define hidden swiftcc i64 @"$s12objc_ns_enum0a1_C7_switchySiAA14ExportedToObjCOF"(i64) +// CHECK-LABEL: define hidden swiftcc i64 @"$s12objc_ns_enum0a1_C7_switchySiAA14ExportedToObjCOF"(i64 %0) // CHECK: switch i64 %0, label {{%.*}} [ // CHECK: i64 -1, label {{%.*}} // CHECK: i64 0, label {{%.*}} @@ -122,17 +122,17 @@ func objc_enum_switch(_ x: ExportedToObjC) -> Int { } @objc class ObjCEnumMethods : NSObject { - // CHECK: define internal void @"$s12objc_ns_enum15ObjCEnumMethodsC0C2InyyAA010ExportedToD1COFTo"([[OBJC_ENUM_METHODS:.*]]*, i8*, i64) + // CHECK: define internal void @"$s12objc_ns_enum15ObjCEnumMethodsC0C2InyyAA010ExportedToD1COFTo"([[OBJC_ENUM_METHODS:.*]]* %0, i8* %1, i64 %2) @objc dynamic func enumIn(_ x: ExportedToObjC) {} - // CHECK: define internal i64 @"$s12objc_ns_enum15ObjCEnumMethodsC0C3OutAA010ExportedToD1COyFTo"([[OBJC_ENUM_METHODS]]*, i8*) + // CHECK: define internal i64 @"$s12objc_ns_enum15ObjCEnumMethodsC0C3OutAA010ExportedToD1COyFTo"([[OBJC_ENUM_METHODS]]* %0, i8* %1) @objc dynamic func enumOut() -> ExportedToObjC { return .Foo } - // CHECK: define internal i64 @"$s12objc_ns_enum15ObjCEnumMethodsC4propAA010ExportedToD1COvgTo"([[OBJC_ENUM_METHODS]]*, i8*) - // CHECK: define internal void @"$s12objc_ns_enum15ObjCEnumMethodsC4propAA010ExportedToD1COvsTo"([[OBJC_ENUM_METHODS]]*, i8*, i64) + // CHECK: define internal i64 @"$s12objc_ns_enum15ObjCEnumMethodsC4propAA010ExportedToD1COvgTo"([[OBJC_ENUM_METHODS]]* %0, i8* %1) + // CHECK: define internal void @"$s12objc_ns_enum15ObjCEnumMethodsC4propAA010ExportedToD1COvsTo"([[OBJC_ENUM_METHODS]]* %0, i8* %1, i64 %2) @objc dynamic var prop: ExportedToObjC = .Foo } -// CHECK-LABEL: define hidden swiftcc void @"$s12objc_ns_enum0a1_C13_method_callsyyAA15ObjCEnumMethodsCF"(%T12objc_ns_enum15ObjCEnumMethodsC*) +// CHECK-LABEL: define hidden swiftcc void @"$s12objc_ns_enum0a1_C13_method_callsyyAA15ObjCEnumMethodsCF"(%T12objc_ns_enum15ObjCEnumMethodsC* %0) func objc_enum_method_calls(_ x: ObjCEnumMethods) { // CHECK: call i64 bitcast (void ()* @objc_msgSend to i64 ([[OBJC_ENUM_METHODS]]*, i8*)*) diff --git a/test/IRGen/objc_pointers.swift b/test/IRGen/objc_pointers.swift index d06885a563abc..73beddef61f90 100644 --- a/test/IRGen/objc_pointers.swift +++ b/test/IRGen/objc_pointers.swift @@ -8,13 +8,13 @@ import Foundation @objc class Foo : NSObject { - // CHECK: define internal void @"$s13objc_pointers3FooC16pointerArguments_1y1z1wySpySiG_SvSPySiGSAyACSgGtFTo"(%0*, i8*, i64*, i8*, i64*, %0**) + // CHECK: define internal void @"$s13objc_pointers3FooC16pointerArguments_1y1z1wySpySiG_SvSPySiGSAyACSgGtFTo"(%0* %0, i8* %1, i64* %2, i8* %3, i64* %4, %0** %5) @objc func pointerArguments(_ x: UnsafeMutablePointer, y: UnsafeMutableRawPointer, z: UnsafePointer, w: AutoreleasingUnsafeMutablePointer) {} - // CHECK: define internal void @"$s13objc_pointers3FooC24pointerMetatypeArguments1x1yySAyyXlXpG_SAyyXlXpSgGtFTo"(%0*, i8*, i8**, i8**) + // CHECK: define internal void @"$s13objc_pointers3FooC24pointerMetatypeArguments1x1yySAyyXlXpG_SAyyXlXpSgGtFTo"(%0* %0, i8* %1, i8** %2, i8** %3) @objc func pointerMetatypeArguments(x: AutoreleasingUnsafeMutablePointer, y: AutoreleasingUnsafeMutablePointer) {} } diff --git a/test/IRGen/objc_protocols.swift b/test/IRGen/objc_protocols.swift index 71d982e4dc454..0ee37d87a6708 100644 --- a/test/IRGen/objc_protocols.swift +++ b/test/IRGen/objc_protocols.swift @@ -130,7 +130,7 @@ func mixed_heritage_erasure(_ x: Zim) -> Frungible { // CHECK: insertvalue { %objc_object*, i8** } [[T0]], i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* [[ZIM_FRUNGIBLE_WITNESS]], i32 0, i32 0), 1 } -// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols0A8_generic{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols0A8_generic{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) {{.*}} { func objc_generic(_ x: T) { x.runce() // CHECK: [[SELECTOR:%.*]] = load i8*, i8** @"\01L_selector(runce)", align 8 @@ -138,13 +138,13 @@ func objc_generic(_ x: T) { // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OBJTYPE]]*, i8*)*)([[OBJTYPE]]* {{%.*}}, i8* [[SELECTOR]]) } -// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols05call_A8_generic{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols05call_A8_generic{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) {{.*}} { // CHECK: call swiftcc void @"$s14objc_protocols0A8_generic{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) func call_objc_generic(_ x: T) { objc_generic(x) } -// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols0A9_protocol{{[_0-9a-zA-Z]*}}F"(%objc_object*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s14objc_protocols0A9_protocol{{[_0-9a-zA-Z]*}}F"(%objc_object* %0) {{.*}} { func objc_protocol(_ x: NSRuncing) { x.runce() // CHECK: [[SELECTOR:%.*]] = load i8*, i8** @"\01L_selector(runce)", align 8 @@ -152,14 +152,14 @@ func objc_protocol(_ x: NSRuncing) { // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OBJTYPE]]*, i8*)*)([[OBJTYPE]]* {{%.*}}, i8* [[SELECTOR]]) } -// CHECK: define hidden swiftcc %objc_object* @"$s14objc_protocols0A8_erasure{{[_0-9a-zA-Z]*}}F"(%TSo7NSSpoonC*) {{.*}} { +// CHECK: define hidden swiftcc %objc_object* @"$s14objc_protocols0A8_erasure{{[_0-9a-zA-Z]*}}F"(%TSo7NSSpoonC* %0) {{.*}} { func objc_erasure(_ x: NSSpoon) -> NSRuncing { return x // CHECK: [[RES:%.*]] = bitcast %TSo7NSSpoonC* {{%.*}} to %objc_object* // CHECK: ret %objc_object* [[RES]] } -// CHECK: define hidden swiftcc void @"$s14objc_protocols0A21_protocol_composition{{[_0-9a-zA-Z]*}}F"(%objc_object*) +// CHECK: define hidden swiftcc void @"$s14objc_protocols0A21_protocol_composition{{[_0-9a-zA-Z]*}}F"(%objc_object* %0) func objc_protocol_composition(_ x: NSRuncing & NSFunging) { x.runce() // CHECK: [[RUNCE:%.*]] = load i8*, i8** @"\01L_selector(runce)", align 8 @@ -170,7 +170,7 @@ func objc_protocol_composition(_ x: NSRuncing & NSFunging) { // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OBJTYPE]]*, i8*)*)([[OBJTYPE]]* {{%.*}}, i8* [[FUNGE]]) } -// CHECK: define hidden swiftcc void @"$s14objc_protocols0A27_swift_protocol_composition{{[_0-9a-zA-Z]*}}F"(%objc_object*, i8**) +// CHECK: define hidden swiftcc void @"$s14objc_protocols0A27_swift_protocol_composition{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, i8** %1) func objc_swift_protocol_composition (_ x: NSRuncing & Ansible & NSFunging) { x.runce() diff --git a/test/IRGen/objc_retainAutoreleasedReturnValue.swift b/test/IRGen/objc_retainAutoreleasedReturnValue.swift index 79bce5b86525d..ef49174b42394 100644 --- a/test/IRGen/objc_retainAutoreleasedReturnValue.swift +++ b/test/IRGen/objc_retainAutoreleasedReturnValue.swift @@ -25,13 +25,13 @@ public func test(_ dict: NSDictionary) { // popq %rbp ;<== Blocks the handshake from objc_autoreleaseReturnValue // jmp 0x01ec20 ; symbol stub for: objc_retainAutoreleasedReturnValue -// CHECK-LABEL: define {{.*}}swiftcc void @"$s34objc_retainAutoreleasedReturnValue4testyySo12NSDictionaryCFyADXEfU_"(%TSo12NSDictionaryC*) +// CHECK-LABEL: define {{.*}}swiftcc void @"$s34objc_retainAutoreleasedReturnValue4testyySo12NSDictionaryCFyADXEfU_"(%TSo12NSDictionaryC* %0) // CHECK: entry: // CHECK: call {{.*}}@objc_msgSend // CHECK: notail call i8* @llvm.objc.retainAutoreleasedReturnValue // CHECK: ret void -// OPT-LABEL: define {{.*}}swiftcc void @"$s34objc_retainAutoreleasedReturnValue4testyySo12NSDictionaryCFyADXEfU_"(%TSo12NSDictionaryC*) +// OPT-LABEL: define {{.*}}swiftcc void @"$s34objc_retainAutoreleasedReturnValue4testyySo12NSDictionaryCFyADXEfU_"(%TSo12NSDictionaryC* %0) // OPT: entry: // OPT: call {{.*}}@objc_msgSend // OPT: notail call i8* @llvm.objc.retainAutoreleasedReturnValue diff --git a/test/IRGen/objc_simd.sil b/test/IRGen/objc_simd.sil index 425063a91e597..1b243c2cd6e15 100644 --- a/test/IRGen/objc_simd.sil +++ b/test/IRGen/objc_simd.sil @@ -13,36 +13,36 @@ func forceStuff(x: float4, y: float3) -> (Float, Float, Float, Float) { } } -// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} <2 x i64> @simd_c_args(<4 x float>) -// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) -// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float>) +// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} <2 x i64> @simd_c_args(<4 x float> %0) +// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) +// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} <4 x float> @simd_c_args(<4 x float> %0) sil @simd_c_args : $@convention(c) (float4) -> float4 { entry(%x : $float4): return %x : $float4 } -// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float>) -// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} <2 x i64> @simd_c_args_float3(<3 x float>) -// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32>) -// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32>) -// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32>) -// armv7-ios-LABEL: define <3 x float> @simd_c_args_float3(<4 x i32>) -// armv7-linux-LABEL: define protected <3 x float> @simd_c_args_float3(<4 x i32>) -// armv7-windows-LABEL: define dllexport <3 x float> @simd_c_args_float3(<4 x i32>) -// armv7-android-LABEL: define protected <3 x float> @simd_c_args_float3(<3 x float>) -// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32>) -// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32>) -// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float>) -// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float>) -// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float>) +// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float> %0) +// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} <2 x i64> @simd_c_args_float3(<3 x float> %0) +// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32> %0) +// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv7-ios-LABEL: define <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv7-linux-LABEL: define protected <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv7-windows-LABEL: define dllexport <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv7-android-LABEL: define protected <3 x float> @simd_c_args_float3(<3 x float> %0) +// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32> %0) +// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<4 x i32> %0) +// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float> %0) +// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float> %0) +// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} <3 x float> @simd_c_args_float3(<3 x float> %0) sil @simd_c_args_float3 : $@convention(c) (float3) -> float3 { entry(%x : $float3): // x86_64: [[COERCE:%.*]] = alloca <3 x float>, align 16 @@ -51,17 +51,17 @@ entry(%x : $float3): return %x : $float3 } -// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @simd_native_args(%T4simd6float4V* noalias nocapture sret, %T4simd6float4V* noalias nocapture dereferenceable({{.*}})) -// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @simd_native_args(%T4simd6float4V* noalias nocapture sret, %T4simd6float4V* noalias nocapture dereferenceable({{.*}})) -// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} void @simd_native_args(%T4simd6float4V* noalias nocapture sret, %T4simd6float4V* noalias nocapture dereferenceable({{.*}})) -// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) -// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float, float, float, float) +// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @simd_native_args(%T4simd6float4V* noalias nocapture sret %0, %T4simd6float4V* noalias nocapture dereferenceable({{.*}}) %1) +// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @simd_native_args(%T4simd6float4V* noalias nocapture sret %0, %T4simd6float4V* noalias nocapture dereferenceable({{.*}}) %1) +// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} void @simd_native_args(%T4simd6float4V* noalias nocapture sret %0, %T4simd6float4V* noalias nocapture dereferenceable({{.*}}) %1) +// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) +// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float, float } @simd_native_args(float %0, float %1, float %2, float %3) sil @simd_native_args : $@convention(thin) (float4) -> float4 { entry(%x : $float4): %f = function_ref @simd_c_args : $@convention(c) (float4) -> float4 @@ -69,17 +69,17 @@ entry(%x : $float4): return %y : $float4 } -// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) -// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float, float, float) +// x86_64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// i386-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// aarch64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// arm64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// armv6-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// armv7-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// armv7s-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// armv7k-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// powerpc64-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// powerpc64le-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) +// s390x-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { float, float, float } @simd_native_args_float3(float %0, float %1, float %2) sil @simd_native_args_float3 : $@convention(thin) (float3) -> float3 { entry(%x : $float3): %f = function_ref @simd_c_args_float3 : $@convention(c) (float3) -> float3 diff --git a/test/IRGen/objc_structs.swift b/test/IRGen/objc_structs.swift index e48d2ff89d482..a1626085624d5 100644 --- a/test/IRGen/objc_structs.swift +++ b/test/IRGen/objc_structs.swift @@ -16,7 +16,7 @@ import gizmo // CHECK: [[NSSTRING:%TSo8NSStringC]] = type opaque // CHECK: [[NSVIEW:%TSo6NSViewC]] = type opaque -// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs8getFrame{{[_0-9a-zA-Z]*}}F"([[GIZMO]]*) {{.*}} { +// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs8getFrame{{[_0-9a-zA-Z]*}}F"([[GIZMO]]* %0) {{.*}} { func getFrame(_ g: Gizmo) -> NSRect { // CHECK: load i8*, i8** @"\01L_selector(frame)" // CHECK: call void bitcast (void ()* @objc_msgSend_stret to void ([[NSRECT]]*, [[OPAQUE0:.*]]*, i8*)*)([[NSRECT]]* noalias nocapture sret {{.*}}, [[OPAQUE0:.*]]* {{.*}}, i8* {{.*}}) @@ -24,7 +24,7 @@ func getFrame(_ g: Gizmo) -> NSRect { } // CHECK: } -// CHECK: define hidden swiftcc void @"$s12objc_structs8setFrame{{[_0-9a-zA-Z]*}}F"(%TSo5GizmoC*, double, double, double, double) {{.*}} { +// CHECK: define hidden swiftcc void @"$s12objc_structs8setFrame{{[_0-9a-zA-Z]*}}F"(%TSo5GizmoC* %0, double %1, double %2, double %3, double %4) {{.*}} { func setFrame(_ g: Gizmo, frame: NSRect) { // CHECK: load i8*, i8** @"\01L_selector(setFrame:)" // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OPAQUE0:.*]]*, i8*, [[NSRECT]]*)*)([[OPAQUE0:.*]]* {{.*}}, i8* {{.*}}, [[NSRECT]]* byval align 8 {{.*}}) @@ -32,28 +32,28 @@ func setFrame(_ g: Gizmo, frame: NSRect) { } // CHECK: } -// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs8makeRect{{[_0-9a-zA-Z]*}}F"(double, double, double, double) +// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs8makeRect{{[_0-9a-zA-Z]*}}F"(double %0, double %1, double %2, double %3) func makeRect(_ a: Double, b: Double, c: Double, d: Double) -> NSRect { // CHECK: call void @NSMakeRect(%struct.NSRect* noalias nocapture sret {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}) return NSMakeRect(a,b,c,d) } // CHECK: } -// CHECK: define hidden swiftcc [[stringLayout:[^@]*]] @"$s12objc_structs14stringFromRect{{[_0-9a-zA-Z]*}}F"(double, double, double, double) {{.*}} { +// CHECK: define hidden swiftcc [[stringLayout:[^@]*]] @"$s12objc_structs14stringFromRect{{[_0-9a-zA-Z]*}}F"(double %0, double %1, double %2, double %3) {{.*}} { func stringFromRect(_ r: NSRect) -> String { // CHECK: call [[OPAQUE0:.*]]* @NSStringFromRect(%struct.NSRect* byval align 8 {{.*}}) return NSStringFromRect(r) } // CHECK: } -// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs9insetRect{{[_0-9a-zA-Z]*}}F"(double, double, double, double, double, double) +// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs9insetRect{{[_0-9a-zA-Z]*}}F"(double %0, double %1, double %2, double %3, double %4, double %5) func insetRect(_ r: NSRect, x: Double, y: Double) -> NSRect { // CHECK: call void @NSInsetRect(%struct.NSRect* noalias nocapture sret {{.*}}, %struct.NSRect* byval align 8 {{.*}}, double {{.*}}, double {{.*}}) return NSInsetRect(r, x, y) } // CHECK: } -// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs19convertRectFromBase{{[_0-9a-zA-Z]*}}F"([[NSVIEW]]*, double, double, double, double) +// CHECK: define hidden swiftcc { double, double, double, double } @"$s12objc_structs19convertRectFromBase{{[_0-9a-zA-Z]*}}F"([[NSVIEW]]* %0, double %1, double %2, double %3, double %4) func convertRectFromBase(_ v: NSView, r: NSRect) -> NSRect { // CHECK: load i8*, i8** @"\01L_selector(convertRectFromBase:)", align 8 // CHECK: call void bitcast (void ()* @objc_msgSend_stret to void ([[NSRECT]]*, [[OPAQUE0:.*]]*, i8*, [[NSRECT]]*)*)([[NSRECT]]* noalias nocapture sret {{.*}}, [[OPAQUE0:.*]]* {{.*}}, i8* {{.*}}, [[NSRECT]]* byval align 8 {{.*}}) @@ -61,7 +61,7 @@ func convertRectFromBase(_ v: NSView, r: NSRect) -> NSRect { } // CHECK: } -// CHECK: define hidden swiftcc { {{.*}}*, {{.*}}*, {{.*}}*, {{.*}}* } @"$s12objc_structs20useStructOfNSStringsySo0deF0VADF"({{.*}}*, {{.*}}*, {{.*}}*, {{.*}}*) +// CHECK: define hidden swiftcc { {{.*}}*, {{.*}}*, {{.*}}*, {{.*}}* } @"$s12objc_structs20useStructOfNSStringsySo0deF0VADF"({{.*}}* %0, {{.*}}* %1, {{.*}}* %2, {{.*}}* %3) // CHECK: call void @useStructOfNSStringsInObjC(%struct.StructOfNSStrings* noalias nocapture sret {{%.*}}, %struct.StructOfNSStrings* byval align 8 {{%.*}}) func useStructOfNSStrings(_ s: StructOfNSStrings) -> StructOfNSStrings { return useStructOfNSStringsInObjC(s) diff --git a/test/IRGen/objc_subscripts.swift b/test/IRGen/objc_subscripts.swift index 3113c823aa8f9..2399743a74312 100644 --- a/test/IRGen/objc_subscripts.swift +++ b/test/IRGen/objc_subscripts.swift @@ -42,7 +42,7 @@ @objc class SomeObject { @objc subscript (i : Int) -> SomeObject { - // CHECK: define internal [[OPAQUE0:%.*]]* @"$s15objc_subscripts10SomeObjectCyACSicigTo"([[OPAQUE1]]*, i8*, i64) {{[#0-9]*}} { + // CHECK: define internal [[OPAQUE0:%.*]]* @"$s15objc_subscripts10SomeObjectCyACSicigTo"([[OPAQUE1]]* %0, i8* %1, i64 %2) {{[#0-9]*}} { get { // CHECK: call swiftcc %T15objc_subscripts10SomeObjectC* @"$s15objc_subscripts10SomeObjectCyACSicig" return self diff --git a/test/IRGen/objc_super.swift b/test/IRGen/objc_super.swift index d04008a877f4a..a58bd1d406bf6 100644 --- a/test/IRGen/objc_super.swift +++ b/test/IRGen/objc_super.swift @@ -17,7 +17,7 @@ import gizmo // CHECK: [[NSRECT:%TSo6NSRectV]] = type class Hoozit : Gizmo { - // CHECK: define hidden swiftcc void @"$s10objc_super6HoozitC4frobyyF"([[HOOZIT]]* swiftself) {{.*}} { + // CHECK: define hidden swiftcc void @"$s10objc_super6HoozitC4frobyyF"([[HOOZIT]]* swiftself %0) {{.*}} { override func frob() { // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s10objc_super6HoozitCMa"([[INT]] 0) // CHECK: [[T0:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -29,7 +29,7 @@ class Hoozit : Gizmo { } // CHECK: } - // CHECK: define hidden swiftcc void @"$s10objc_super6HoozitC5runceyyFZ"(%swift.type* swiftself) {{.*}} { + // CHECK: define hidden swiftcc void @"$s10objc_super6HoozitC5runceyyFZ"(%swift.type* swiftself %0) {{.*}} { override class func runce() { // CHECK: store [[CLASS]]* @"OBJC_METACLASS_$__TtC10objc_super6Hoozit", [[CLASS]]** {{.*}}, align 8 // CHECK: load i8*, i8** @"\01L_selector(runce)" @@ -38,7 +38,7 @@ class Hoozit : Gizmo { } // CHECK: } - // CHECK: define hidden swiftcc { double, double, double, double } @"$s10objc_super6HoozitC5frameSo6NSRectVyF"(%T10objc_super6HoozitC* swiftself) {{.*}} { + // CHECK: define hidden swiftcc { double, double, double, double } @"$s10objc_super6HoozitC5frameSo6NSRectVyF"(%T10objc_super6HoozitC* swiftself %0) {{.*}} { override func frame() -> NSRect { // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s10objc_super6HoozitCMa"([[INT]] 0) // CHECK: [[T0:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -50,7 +50,7 @@ class Hoozit : Gizmo { } // CHECK: } - // CHECK: define hidden swiftcc [[HOOZIT]]* @"$s10objc_super6HoozitC1xACSi_tcfc"(i64, %T10objc_super6HoozitC* swiftself) {{.*}} { + // CHECK: define hidden swiftcc [[HOOZIT]]* @"$s10objc_super6HoozitC1xACSi_tcfc"(i64 %0, %T10objc_super6HoozitC* swiftself %1) {{.*}} { init(x:Int) { // CHECK: load i8*, i8** @"\01L_selector(init)" // CHECK: call [[OPAQUE:.*]]* bitcast (void ()* @objc_msgSendSuper2 to [[OPAQUE:.*]]* (%objc_super*, i8*)*)([[SUPER]]* {{.*}}, i8* {{.*}}) @@ -60,7 +60,7 @@ class Hoozit : Gizmo { } // CHECK: } - // CHECK: define hidden swiftcc [[HOOZIT]]* @"$s10objc_super6HoozitC1yACSi_tcfc"(i64, %T10objc_super6HoozitC* swiftself) {{.*}} { + // CHECK: define hidden swiftcc [[HOOZIT]]* @"$s10objc_super6HoozitC1yACSi_tcfc"(i64 %0, %T10objc_super6HoozitC* swiftself %1) {{.*}} { init(y:Int) { // CHECK: load i8*, i8** @"\01L_selector(initWithBellsOn:)" // CHECK: call [[OPAQUE:.*]]* bitcast (void ()* @objc_msgSendSuper2 to [[OPAQUE:.*]]* (%objc_super*, i8*, i64)*)([[SUPER]]* {{.*}}, i8* {{.*}}, i64 {{.*}}) @@ -74,7 +74,7 @@ class Hoozit : Gizmo { func acceptFn(_ fn: () -> Void) { } class PartialApply : Gizmo { - // CHECK: define hidden swiftcc void @"$s10objc_super12PartialApplyC4frobyyF"([[PARTIAL_APPLY_CLASS]]* swiftself) {{.*}} { + // CHECK: define hidden swiftcc void @"$s10objc_super12PartialApplyC4frobyyF"([[PARTIAL_APPLY_CLASS]]* swiftself %0) {{.*}} { override func frob() { // CHECK: call swiftcc void @"$s10objc_super8acceptFnyyyyXEF"(i8* bitcast (void (%swift.refcounted*)* [[PARTIAL_FORWARDING_THUNK:@"\$[A-Za-z0-9_]+"]] to i8*), %swift.opaque* %{{[0-9]+}}) acceptFn(super.frob) @@ -89,7 +89,7 @@ class GenericRuncer : Gizmo { // Use a constant indirect field access instead of a non-constant direct // access because the layout dependents on the alignment of y. -// CHECK: define hidden swiftcc i64 @"$s10objc_super13GenericRuncerC1xSo5GizmoCSgvg"(%T10objc_super13GenericRuncerC* swiftself) +// CHECK: define hidden swiftcc i64 @"$s10objc_super13GenericRuncerC1xSo5GizmoCSgvg"(%T10objc_super13GenericRuncerC* swiftself %0) // CHECK: inttoptr // CHECK: [[CAST:%.*]] = bitcast %T10objc_super13GenericRuncerC* %0 to i64* // CHECK: [[ISA:%.*]] = load i64, i64* [[CAST]] @@ -109,7 +109,7 @@ class GenericRuncer : Gizmo { // CHECK: call i8* @llvm.objc.retain(i8* [[OBJ_CAST]]) // CHECK: ret i64 [[OPTIONAL]] - // CHECK: define hidden swiftcc void @"$s10objc_super13GenericRuncerC5runceyyFZ"(%swift.type* swiftself) {{.*}} { + // CHECK: define hidden swiftcc void @"$s10objc_super13GenericRuncerC5runceyyFZ"(%swift.type* swiftself %0) {{.*}} { override class func runce() { // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s10objc_super13GenericRuncerCMa"([[INT]] 0, %swift.type* %T) // CHECK-NEXT: [[CLASS:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -129,7 +129,7 @@ class GenericRuncer : Gizmo { } } -// CHECK: define internal swiftcc void [[PARTIAL_FORWARDING_THUNK]](%swift.refcounted* swiftself) #0 { +// CHECK: define internal swiftcc void [[PARTIAL_FORWARDING_THUNK]](%swift.refcounted* swiftself %0) {{.*}} { // CHECK: call swiftcc %swift.metadata_response @"$s10objc_super12PartialApplyCMa"([[INT]] 0) // CHECK: @"\01L_selector(frob)" // CHECK: call void bitcast (void ()* @objc_msgSendSuper2 diff --git a/test/IRGen/objc_types_as_member.sil b/test/IRGen/objc_types_as_member.sil index 013f006b943cb..381b3528e4137 100644 --- a/test/IRGen/objc_types_as_member.sil +++ b/test/IRGen/objc_types_as_member.sil @@ -8,7 +8,7 @@ import gizmo sil @use_metatype : $@convention(thin) (@thin T.Type) -> () -// CHECK-LABEL: define swiftcc void @test(%TSo014OuterTypeInnerB0C* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define swiftcc void @test(%TSo014OuterTypeInnerB0C* swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // FIXME: Metadata realization via demangling is disabled for now // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$sSo9OuterTypeCMa" // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response %1, 0 diff --git a/test/IRGen/opaque_result_type.swift b/test/IRGen/opaque_result_type.swift index 9b704767c90e7..a1fb4fd4a3c58 100644 --- a/test/IRGen/opaque_result_type.swift +++ b/test/IRGen/opaque_result_type.swift @@ -163,7 +163,7 @@ public func useFoo(x: String, y: C) { // CHECK-LABEL: define {{.*}} @"$s18opaque_result_type6useFoo1x1yySS_AA1CCtF" // CHECK: [[OPAQUE:%.*]] = call {{.*}} @"$s18opaque_result_type3baz1zQrx_tAA1PRzAA1QRzlFQOMg" // CHECK: [[CONFORMANCE:%.*]] = call swiftcc i8** @swift_getOpaqueTypeConformance(i8* {{.*}}, %swift.type_descriptor* [[OPAQUE]], [[WORD:i32|i64]] 1) -// CHECK: [[TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s18opaque_result_type3baz1zQrx_tAA1PRzAA1QRzlFQOyAA1CCQo_MD") +// CHECK: [[TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}} @"$s18opaque_result_type3baz1zQrx_tAA1PRzAA1QRzlFQOyAA1CCQo_MD") // CHECK: call swiftcc i8** @swift_getAssociatedConformanceWitness(i8** [[CONFORMANCE]], %swift.type* [[TYPE]] // CHECK-LABEL: define {{.*}} @"$sSS18opaque_result_type1PAA1AAaBP_AA1OPWT" diff --git a/test/IRGen/opaque_values_irgen.sil b/test/IRGen/opaque_values_irgen.sil index 787282e400950..9fd5d5c12a9a7 100644 --- a/test/IRGen/opaque_values_irgen.sil +++ b/test/IRGen/opaque_values_irgen.sil @@ -4,7 +4,7 @@ import Builtin sil_stage canonical -// CHECK: define hidden swiftcc void @f010_irgen_identity(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T) +// CHECK: define hidden swiftcc void @f010_irgen_identity(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %T) // CHECK: entry: // CHECK-NOT: call // CHECK: %{{.*}} = call %swift.opaque* %initializeWithTake(%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* %T) diff --git a/test/IRGen/open_boxed_existential.sil b/test/IRGen/open_boxed_existential.sil index c154ab2df24d2..1fc9167606a82 100644 --- a/test/IRGen/open_boxed_existential.sil +++ b/test/IRGen/open_boxed_existential.sil @@ -2,7 +2,7 @@ import Swift -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i[0-9]+}} @open_boxed_existential(%swift.error*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i[0-9]+}} @open_boxed_existential(%swift.error* %0) sil @open_boxed_existential : $@convention(thin) (@owned Error) -> Int { entry(%b : $Error): // CHECK: call void @swift_getErrorValue(%swift.error* %0, i8** {{%.*}}, [[TRIPLE:{ %swift.opaque\*, %swift.type\*, i8\*\* }]]* [[OUT:%.*]]) diff --git a/test/IRGen/optional_metatype.sil b/test/IRGen/optional_metatype.sil index 926d10f24f700..25348e464cd74 100644 --- a/test/IRGen/optional_metatype.sil +++ b/test/IRGen/optional_metatype.sil @@ -8,17 +8,17 @@ import Builtin import Swift import gizmo -// x86_64-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i64) +// x86_64-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i64 %0) // x86_64: icmp eq i64 %0, 0 -// i386-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32) +// i386-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32 %0) // i386: icmp eq i32 %0, 0 -// arm64-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i64) +// arm64-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i64 %0) // arm64: icmp eq i64 %0, 0 -// armv7-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32) +// armv7-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32 %0) // armv7: icmp eq i32 %0, 0 -// armv7s-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32) +// armv7s-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32 %0) // armv7s: icmp eq i32 %0, 0 -// armv7k-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32) +// armv7k-LABEL: define{{( protected)?}} swiftcc void @optional_objc_metatype(i32 %0) // armv7k: icmp eq i32 %0, 0 sil @optional_objc_metatype : $@convention(thin) (Optional<@objc_metatype Gizmo.Type>) -> () { @@ -32,17 +32,17 @@ cont: return undef : $() } -// x86_64-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i64) +// x86_64-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i64 %0) // x86_64: icmp eq i64 %0, 0 -// i386-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32) +// i386-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32 %0) // i386: icmp eq i32 %0, 0 -// arm64-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i64) +// arm64-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i64 %0) // arm64: icmp eq i64 %0, 0 -// armv7-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32) +// armv7-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32 %0) // armv7: icmp eq i32 %0, 0 -// armv7s-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32) +// armv7s-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32 %0) // armv7s: icmp eq i32 %0, 0 -// armv7k-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32) +// armv7k-LABEL: define{{( protected)?}} swiftcc void @optional_swift_metatype(i32 %0) // armv7k: icmp eq i32 %0, 0 sil @optional_swift_metatype : $@convention(thin) (Optional<@thick Gizmo.Type>) -> () { diff --git a/test/IRGen/outlined_copy_addr.swift b/test/IRGen/outlined_copy_addr.swift index c03d8ff96b1c3..31c608171578a 100644 --- a/test/IRGen/outlined_copy_addr.swift +++ b/test/IRGen/outlined_copy_addr.swift @@ -18,7 +18,7 @@ public struct StructWithBaseStruct { var elem2: BaseStruct } -// CHECK-LABEL: define hidden swiftcc void @"$s11outcopyaddr010StructWithbc4BaseB0V4elemAA0bcdB0VyxGvg"(%T11outcopyaddr014StructWithBaseB0V.5* noalias nocapture sret, %swift.type* %"StructWithStructWithBaseStruct", %T11outcopyaddr010StructWithbc4BaseB0V* noalias nocapture swiftself) +// CHECK-LABEL: define hidden swiftcc void @"$s11outcopyaddr010StructWithbc4BaseB0V4elemAA0bcdB0VyxGvg"(%T11outcopyaddr014StructWithBaseB0V.5* noalias nocapture sret %0, %swift.type* %"StructWithStructWithBaseStruct", %T11outcopyaddr010StructWithbc4BaseB0V* noalias nocapture swiftself %1) // CHECK: call %T11outcopyaddr014StructWithBaseB0V.5* @"$s11outcopyaddr014StructWithBaseB0VyxGAA9ChildProtRzlWOc" public struct StructWithStructWithBaseStruct { public typealias Element = T @@ -36,7 +36,7 @@ struct OtherInternal { struct MyPrivate { var otherHelper: OtherInternal? = nil - // CHECK-LABEL: define hidden swiftcc {{i32|i64}} @"$s11outcopyaddr9MyPrivateVyACyxGxcfC"(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.P) {{.*}} { + // CHECK-LABEL: define hidden swiftcc {{i32|i64}} @"$s11outcopyaddr9MyPrivateVyACyxGxcfC"(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.P) {{.*}} { // CHECK: call %T11outcopyaddr9MyPrivateV* @"$s11outcopyaddr9MyPrivateVyxGAA1PRzlWOh"(%T11outcopyaddr9MyPrivateV* {{%.*}}) // CHECK: ret init(_: T) { } diff --git a/test/IRGen/partial_apply.sil b/test/IRGen/partial_apply.sil index 13135833dce0f..7a0f932e3752c 100644 --- a/test/IRGen/partial_apply.sil +++ b/test/IRGen/partial_apply.sil @@ -14,7 +14,7 @@ sil @partially_applyable_to_two_classes : $@convention(thin) (@owned SwiftClass, sil @use_closure : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> () -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_class(%T13partial_apply10SwiftClassC*) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_class(%T13partial_apply10SwiftClassC* %0) {{.*}} { // CHECK: entry: // CHECK: %1 = bitcast %T13partial_apply10SwiftClassC* %0 to %swift.refcounted* // CHECK: %2 = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$s28partially_applyable_to_classTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* %1, 1 @@ -27,7 +27,7 @@ entry(%c : $SwiftClass): return %g : $@callee_owned () -> () } -// CHECK: define{{.*}} swiftcc void @partial_apply_class_on_stack(%T13partial_apply10SwiftClassC*) +// CHECK: define{{.*}} swiftcc void @partial_apply_class_on_stack(%T13partial_apply10SwiftClassC* %0) // CHECK: entry: // CHECK: [[CTX:%.*]] = bitcast %T13partial_apply10SwiftClassC* %0 to %swift.opaque* // CHECK: call swiftcc void @use_closure(i8* bitcast (void (%swift.refcounted*)* @"$s28partially_applyable_to_classTA.1" to i8*), %swift.opaque* [[CTX]]) @@ -47,7 +47,7 @@ entry(%a : $SwiftClass): return %t : $() } -// CHECK: define{{.*}} swiftcc void @partial_apply_two_classes_on_stack(%T13partial_apply10SwiftClassC*, %T13partial_apply10SwiftClassC*) +// CHECK: define{{.*}} swiftcc void @partial_apply_two_classes_on_stack(%T13partial_apply10SwiftClassC* %0, %T13partial_apply10SwiftClassC* %1) // CHECK: entry: // CHECK: [[CTX:%.*]] = alloca i8, i64 32, align 16 // CHECK: [[CTX2:%.*]] = bitcast i8* [[CTX]] to %swift.opaque* @@ -79,7 +79,7 @@ entry(%a : $SwiftClass, %b: $SwiftClass): // in the forwarder. // -// CHECK-LABEL: define internal swiftcc i64 @"$s22generic_captured_paramTA"(i64, %swift.refcounted* swiftself) {{.*}} { +// CHECK-LABEL: define internal swiftcc i64 @"$s22generic_captured_paramTA"(i64 %0, %swift.refcounted* swiftself %1) {{.*}} { // CHECK: bitcast %TSi* {{%.*}} to %swift.opaque* sil public_external @generic_captured_param : $@convention(thin) (Int, @inout T) -> Int @@ -116,7 +116,7 @@ entry(%a : $*T): sil public_external @guaranteed_captured_class_param : $@convention(thin) (Int, @guaranteed SwiftClass) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_guaranteed_class_param(%T13partial_apply10SwiftClassC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_guaranteed_class_param(%T13partial_apply10SwiftClassC* %0) // CHECK: [[CONTEXT_OBJ:%.*]] = bitcast %T13partial_apply10SwiftClassC* {{%.*}} to %swift.refcounted* // CHECK: [[T0:%.*]] = insertvalue {{.*}} [[PARTIAL_APPLY_FORWARDER:@"\$s[A-Za-z0-9_]+TA"]] {{.*}} [[CONTEXT_OBJ]] // CHECK: ret {{.*}} [[T0]] @@ -137,7 +137,7 @@ bb0(%x : $SwiftClass): sil public_external @indirect_guaranteed_captured_class_param : $@convention(thin) (Int, @in_guaranteed SwiftClass) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_guaranteed_class_param(%T13partial_apply10SwiftClassC** noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_guaranteed_class_param(%T13partial_apply10SwiftClassC** noalias nocapture dereferenceable({{.*}}) %0) // CHECK-NOT: {{retain|release}} // CHECK: [[X:%.*]] = load %T13partial_apply10SwiftClassC*, %T13partial_apply10SwiftClassC** %0 // CHECK-NEXT: [[CONTEXT_OBJ:%.*]] = bitcast %T13partial_apply10SwiftClassC* [[X]] to %swift.refcounted* @@ -166,7 +166,7 @@ bb0(%x : $*SwiftClass): sil public_external @indirect_consumed_captured_class_param : $@convention(thin) (Int, @in SwiftClass) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_consumed_class_param(%T13partial_apply10SwiftClassC** noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_consumed_class_param(%T13partial_apply10SwiftClassC** noalias nocapture dereferenceable({{.*}}) %0) // CHECK-NOT: {{retain|release}} // CHECK: [[X:%.*]] = load %T13partial_apply10SwiftClassC*, %T13partial_apply10SwiftClassC** %0 // CHECK-NEXT: [[CONTEXT_OBJ:%.*]] = bitcast %T13partial_apply10SwiftClassC* [[X]] to %swift.refcounted* @@ -202,7 +202,7 @@ struct SwiftClassPair { var x: SwiftClass, y: SwiftClass } sil public_external @guaranteed_captured_class_pair_param : $@convention(thin) (Int, @guaranteed SwiftClassPair) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_guaranteed_class_pair_param(%T13partial_apply10SwiftClassC*, %T13partial_apply10SwiftClassC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_guaranteed_class_pair_param(%T13partial_apply10SwiftClassC* %0, %T13partial_apply10SwiftClassC* %1) // CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK: [[PAIR_ADDR:%.*]] = getelementptr // CHECK-NEXT: [[X_ADDR:%.*]] = getelementptr inbounds %T13partial_apply14SwiftClassPairV, %T13partial_apply14SwiftClassPairV* [[PAIR_ADDR]], i32 0, i32 0 @@ -233,7 +233,7 @@ bb0(%x : $SwiftClassPair): sil public_external @indirect_guaranteed_captured_class_pair_param : $@convention(thin) (Int, @in_guaranteed SwiftClassPair) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_guaranteed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_guaranteed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}}) %0) // CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK-NOT: {{retain|release}} // CHECK: [[T0:%.*]] = insertvalue {{.*}} [[PARTIAL_APPLY_FORWARDER:@"\$s[A-Za-z0-9_]+TA"]] {{.*}} [[CONTEXT_OBJ]] @@ -256,7 +256,7 @@ bb0(%x : $*SwiftClassPair): sil public_external @indirect_consumed_captured_class_pair_param : $@convention(thin) (Int, @in SwiftClassPair) -> Int -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_consumed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_consumed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}}) %0) // CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK-NOT: {{retain|release}} // CHECK: [[T0:%.*]] = insertvalue {{.*}} [[PARTIAL_APPLY_FORWARDER:@"\$s[A-Za-z0-9_]+TA"]] {{.*}} [[CONTEXT_OBJ]] @@ -278,7 +278,7 @@ bb0(%x : $*SwiftClassPair): sil public_external @captured_fixed_and_dependent_params : $@convention(thin) (@owned SwiftClass, @in A, Int) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_non_fixed_layout(%T13partial_apply10SwiftClassC*, %swift.opaque* noalias nocapture, i64, %swift.type* %T) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_non_fixed_layout(%T13partial_apply10SwiftClassC* %0, %swift.opaque* noalias nocapture %1, i64 %2, %swift.type* %T) // -- Round the base offset for the T field up to T's alignment. // CHECK: [[T_METADATA_BASE:%.*]] = bitcast %swift.type* %T to i8*** // CHECK: [[T_VWTABLE_ADDR:%.*]] = getelementptr {{.*}} [[T_METADATA_BASE]], [[WORD:i[0-9]+]] -1 @@ -335,7 +335,7 @@ sil public_external @captured_fixed_and_dependent_params : $@convention(thin) (@owned SwiftClass, @in T, Int) -> @callee_owned () -> () { bb0(%a : $SwiftClass, %b : $*T, %c : $Int): %f = function_ref @captured_fixed_and_dependent_params : $@convention(thin) (@owned SwiftClass, @in B, Int) -> () @@ -352,7 +352,7 @@ bb0(%x : $*T): return %p : $@callee_owned () -> @out T } -// CHECK-LABEL: define internal swiftcc void @"$s28captured_dependent_out_paramTA"(%swift.opaque* noalias nocapture sret, %swift.refcounted* swiftself) {{.*}} { +// CHECK-LABEL: define internal swiftcc void @"$s28captured_dependent_out_paramTA"(%swift.opaque* noalias nocapture sret %0, %swift.refcounted* swiftself %1) {{.*}} { // CHECK: call swiftcc void @captured_dependent_out_param(%swift.opaque* noalias nocapture sret sil @partial_apply_dynamic_with_out_param : $@convention(thin) (Int32, @owned @callee_owned (Int32) -> @out T) -> @callee_owned () -> @out T { @@ -383,19 +383,19 @@ bb0(%0 : $Base): sil public_external @receive_closure : $@convention(thin) (@owned @callee_owned () -> (@owned C)) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_partial_apply(%T13partial_apply4BaseC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_partial_apply(%T13partial_apply4BaseC* %0) // CHECK: [[CTX:%.*]] = bitcast %T13partial_apply4BaseC* %0 to %swift.refcounted* // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s13partial_apply3SubCMa"(i64 0) // CHECK: [[TYPE:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: call swiftcc void @receive_closure(i8* bitcast (%T13partial_apply3SubC* (%swift.refcounted*)* @"$s26parametric_casting_closureTA.{{[0-9]+}}" to i8*), %swift.refcounted* [[CTX]], %swift.type* [[TYPE]]) -// CHECK-LABEL: define internal swiftcc %T13partial_apply3SubC* @"$s26parametric_casting_closureTA"(%T13partial_apply4BaseC*, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc %T13partial_apply3SubC* @"$s26parametric_casting_closureTA"(%T13partial_apply4BaseC* %0, %swift.refcounted* swiftself %1) // CHECK: [[RES:%.*]] = tail call swiftcc %T13partial_apply4BaseC* @parametric_casting_closure // CHECK: [[CASTED:%.*]] = bitcast %T13partial_apply4BaseC* [[RES]] to %T13partial_apply3SubC* // CHECK: ret %T13partial_apply3SubC* [[CASTED]] -// CHECK-LABEL: define internal swiftcc %T13partial_apply3SubC* @"$s26parametric_casting_closureTA.{{[0-9]+}}"(%swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc %T13partial_apply3SubC* @"$s26parametric_casting_closureTA.{{[0-9]+}}"(%swift.refcounted* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s13partial_apply3SubCMa"(i64 0) // CHECK: [[TYPE:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[CTX:%.*]] = bitcast %swift.refcounted* %0 to %T13partial_apply4BaseC* @@ -442,7 +442,7 @@ bb0(%0 : $Int): %result = tuple () return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @partial_apply_complex_generic_function(i64, %swift.type* %T, i8** %T.P2, i8** %T.Y.P2) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @partial_apply_complex_generic_function(i64 %0, %swift.type* %T, i8** %T.P2, i8** %T.Y.P2) // CHECK: [[T0:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}}, i64 48, i64 7) // CHECK-NEXT: [[T1:%.*]] = bitcast %swift.refcounted* [[T0]] to <{ %swift.refcounted, [24 x i8], %TSi }>* // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds <{ %swift.refcounted, [24 x i8], %TSi }>, <{ %swift.refcounted, [24 x i8], %TSi }>* [[T1]], i32 0, i32 1 @@ -455,7 +455,7 @@ bb0(%0 : $Int): // CHECK-NEXT: [[T1:%.*]] = bitcast %swift.type** [[T0]] to i8*** // CHECK-NEXT: store i8** %T.Y.P2, i8*** [[T1]], align 8 -// CHECK-LABEL: define internal swiftcc void @"$s24complex_generic_functionTA"(%swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s24complex_generic_functionTA"(%swift.refcounted* swiftself %0) // CHECK: [[T0:%.*]] = bitcast %swift.refcounted* %0 to <{ %swift.refcounted, [24 x i8], %TSi }>* // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds <{ %swift.refcounted, [24 x i8], %TSi }>, <{ %swift.refcounted, [24 x i8], %TSi }>* [[T0]], i32 0, i32 1 // CHECK-NEXT: [[BUFFER:%.*]] = bitcast [24 x i8]* [[T1]] to %swift.type** @@ -507,7 +507,7 @@ sil public_external @generic_indirect_return : $@convention(thin) (Int) -> @ // CHECK-LABEL: define{{.*}} @partial_apply_generic_indirect_return // CHECK: insertvalue {{.*}}$s23generic_indirect_returnTA -// CHECK-LABEL: define internal swiftcc void @"$s23generic_indirect_returnTA"(%T13partial_apply11GenericEnumOySiG* noalias nocapture sret, %swift.refcounted* swiftself +// CHECK-LABEL: define internal swiftcc void @"$s23generic_indirect_returnTA"(%T13partial_apply11GenericEnumOySiG* noalias nocapture sret %0, %swift.refcounted* swiftself // CHECK: [[CASTEDRETURN:%.*]] = bitcast %T13partial_apply11GenericEnumOySiG* %0 to %T13partial_apply11GenericEnumO* // CHECK: call swiftcc void @generic_indirect_return({{.*}}[[CASTEDRETURN]] // CHECK: ret void @@ -536,7 +536,7 @@ sil public_external @generic_indirect_return2 : $@convention(thin) (Int) -> // CHECK: [[R2:%.*]] = insertvalue { i8*, %swift.refcounted* } [[R1]], %swift.refcounted* [[CTX2]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[R2]] -// CHECK-LABEL: define internal swiftcc void @"$s24generic_indirect_return2TA"(%T13partial_apply12GenericEnum2OySiG* noalias nocapture sret, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s24generic_indirect_return2TA"(%T13partial_apply12GenericEnum2OySiG* noalias nocapture sret %0, %swift.refcounted* swiftself %1) // CHECK: [[CASTED_ADDR:%.*]] = bitcast %T13partial_apply12GenericEnum2OySiG* %0 to %T13partial_apply12GenericEnum2O* // CHECK: call swiftcc void @generic_indirect_return2(%T13partial_apply12GenericEnum2O* noalias nocapture sret [[CASTED_ADDR]] // CHECK: ret void @@ -551,7 +551,7 @@ struct SwiftStruct {} sil @fun : $@convention(thin) (@thin SwiftStruct.Type, @owned SwiftClass) -> () -// CHECK-LABEL: define{{.*}} swiftcc { i8*, %swift.refcounted* } @partial_apply_thin_type(%T13partial_apply10SwiftClassC*) +// CHECK-LABEL: define{{.*}} swiftcc { i8*, %swift.refcounted* } @partial_apply_thin_type(%T13partial_apply10SwiftClassC* %0) // CHECK: [[CONTEXT:%.*]] = bitcast %T13partial_apply10SwiftClassC* %0 to %swift.refcounted* // CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$s3funTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[CONTEXT]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[CLOSURE]] @@ -611,7 +611,7 @@ bb0(%0 : $*A2): sil @capture_class : $@convention(thin) (@guaranteed A3) -> () -// CHECK-LABEL: define{{.*}} swiftcc i8* @partial_apply_stack_in_coroutine(i8* {{.*}}, %T13partial_apply2A3C*) +// CHECK-LABEL: define{{.*}} swiftcc i8* @partial_apply_stack_in_coroutine(i8* {{.*}} %0, %T13partial_apply2A3C* %1) // CHECK: entry: // CHECK: [[CLOSURE_CONTEXT:%.*]] = bitcast %T13partial_apply2A3C* %1 to %swift.opaque* // CHECK: [[CONTEXT:%.*]] = bitcast %swift.opaque* [[CLOSURE_CONTEXT]] to %swift.refcounted* diff --git a/test/IRGen/partial_apply_forwarder.sil b/test/IRGen/partial_apply_forwarder.sil index 96bd16451b7dd..8a9909dc133f8 100644 --- a/test/IRGen/partial_apply_forwarder.sil +++ b/test/IRGen/partial_apply_forwarder.sil @@ -78,7 +78,7 @@ sil hidden_external @takingQ : $@convention(thin) <τ_0_0 where τ_0_0 : Q> (@o sil hidden_external @takingQAndEmpty : $@convention(thin) <τ_0_0 where τ_0_0 : Q> (@owned WeakBox<τ_0_0>, EmptyType) -> () sil hidden_external @takingEmptyAndQ : $@convention(thin) <τ_0_0 where τ_0_0 : Q> (EmptyType, @owned WeakBox<τ_0_0>) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1") +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_0_1") // CHECK: entry: // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s23partial_apply_forwarder12BaseProducerVMa"([[INT]] 255, %swift.type* %"\CF\84_0_1") // CHECK: [[BPTYPE:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -90,7 +90,7 @@ sil hidden_external @takingEmptyAndQ : $@convention(thin) <τ_0_0 where τ_0_0 // CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$s7takingQTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[REF]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[CLOSURE]] -// CHECK-LABEL: define internal swiftcc void @"$s7takingQTA"(%swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s7takingQTA"(%swift.refcounted* swiftself %0) // CHECK: entry: // CHECK: [[WB:%.*]] = bitcast %swift.refcounted* %0 to %T23partial_apply_forwarder7WeakBoxC* // CHECK: [[TYADDR:%.*]] = getelementptr inbounds %T23partial_apply_forwarder7WeakBoxC, %T23partial_apply_forwarder7WeakBoxC* %1, i32 0, i32 0, i32 0 @@ -111,7 +111,7 @@ bb0(%0 : $*τ_0_1): return %9 : $@callee_owned () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_2(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1") +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_2(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_0_1") // CHECK: [[OBJ:%.*]] = call {{.*}} @swift_allocObject // CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[OBJ]] // CHECK: [[REF:%.*]] = bitcast {{.*}}* [[WB]] to %swift.refcounted* @@ -125,7 +125,7 @@ bb0(%0 : $*τ_0_1, %2: $EmptyType): return %9 : $@callee_owned () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_3(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1") +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_3(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_0_1") // CHECK: [[OBJ:%.*]] = call {{.*}} @swift_allocObject // CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[OBJ]] // CHECK: [[REF:%.*]] = bitcast {{.*}}* [[WB]] to %swift.refcounted* @@ -140,7 +140,7 @@ bb0(%0 : $*τ_0_1, %2: $EmptyType): return %9 : $@callee_owned () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bind_polymorphic_param_from_forwarder_parameter(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1") +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bind_polymorphic_param_from_forwarder_parameter(%swift.opaque* noalias nocapture %0, %swift.type* %"\CF\84_0_1") // CHECK: entry: // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s23partial_apply_forwarder12BaseProducerVMa"([[INT]] 255, %swift.type* %"\CF\84_0_1") // CHECK: [[BPTY:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -149,7 +149,7 @@ bb0(%0 : $*τ_0_1, %2: $EmptyType): // CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[WBTY]] // CHECK: ret void -// CHECK-LABEL: define internal swiftcc void @"$s7takingQTA.1"(%T23partial_apply_forwarder7WeakBoxC*, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s7takingQTA.1"(%T23partial_apply_forwarder7WeakBoxC* %0, %swift.refcounted* swiftself %1) // CHECK: entry: // CHECK: [[TYADDR:%.*]] = getelementptr inbounds %T23partial_apply_forwarder7WeakBoxC, %T23partial_apply_forwarder7WeakBoxC* %0 // CHECK: [[TY:%.*]] = load %swift.type*, %swift.type** [[TYADDR]] @@ -176,7 +176,7 @@ struct S { sil hidden_external @takingQAndS : $@convention(thin) <τ_0_0 where τ_0_0 : Q> (S, @owned WeakBox<τ_0_0>) -> () -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_with_layout(%swift.opaque* noalias nocapture, i64, %swift.type* %"\CF\84_0_1") +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_with_layout(%swift.opaque* noalias nocapture %0, i64 %1, %swift.type* %"\CF\84_0_1") // CHECK: entry: // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s23partial_apply_forwarder12BaseProducerVMa"([[INT]] 255, %swift.type* %"\CF\84_0_1") // CHECK: [[BPTY:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 @@ -194,7 +194,7 @@ sil hidden_external @takingQAndS : $@convention(thin) <τ_0_0 where τ_0_0 : Q> // CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$s11takingQAndSTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[CONTEXT0]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[CLOSURE]] -// CHECK-LABEL: define internal swiftcc void @"$s11takingQAndSTA"(%swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc void @"$s11takingQAndSTA"(%swift.refcounted* swiftself %0) // CHECK: entry: // CHECK: [[CONTEXT:%.*]] = bitcast %swift.refcounted* %0 to <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>* // CHECK: [[SADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>, <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>* [[CONTEXT]], i32 0, i32 {{(1|2)}} diff --git a/test/IRGen/partial_apply_generic.swift b/test/IRGen/partial_apply_generic.swift index 11b0c9ca3b582..e012878d01166 100644 --- a/test/IRGen/partial_apply_generic.swift +++ b/test/IRGen/partial_apply_generic.swift @@ -37,7 +37,7 @@ var x = seq ~> split // Indirect return // -// CHECK-LABEL: define internal swiftcc { i8*, %swift.refcounted* } @"$s21partial_apply_generic5split{{[_0-9a-zA-Z]*}}FTA"(%T21partial_apply_generic5SpoonV* noalias nocapture, %swift.refcounted* swiftself) +// CHECK-LABEL: define internal swiftcc { i8*, %swift.refcounted* } @"$s21partial_apply_generic5split{{[_0-9a-zA-Z]*}}FTA"(%T21partial_apply_generic5SpoonV* noalias nocapture %0, %swift.refcounted* swiftself %1) // CHECK: [[REABSTRACT:%.*]] = bitcast %T21partial_apply_generic5SpoonV* %0 to %swift.opaque* // CHECK: tail call swiftcc { i8*, %swift.refcounted* } @"$s21partial_apply_generic5split{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture [[REABSTRACT]], @@ -48,7 +48,7 @@ struct S { let s = S() var y = s.hugeStructReturn -// CHECK-LABEL: define internal swiftcc { i64, i64, i64, i64 } @"$s21partial_apply_generic1SV16hugeStructReturnyAA04HugeE0VAFFTA"(i64, i64, i64, i64, %swift.refcounted* swiftself) #0 { +// CHECK-LABEL: define internal swiftcc { i64, i64, i64, i64 } @"$s21partial_apply_generic1SV16hugeStructReturnyAA04HugeE0VAFFTA"(i64 %0, i64 %1, i64 %2, i64 %3, %swift.refcounted* swiftself %4) {{.*}} { // CHECK: entry: // CHECK: %5 = tail call swiftcc { i64, i64, i64, i64 } @"$s21partial_apply_generic1SV16hugeStructReturnyAA04HugeE0VAFF"(i64 %0, i64 %1, i64 %2, i64 %3) // CHECK: ret { i64, i64, i64, i64 } %5 diff --git a/test/IRGen/partial_apply_objc.sil b/test/IRGen/partial_apply_objc.sil index c3622aaa6be23..83430837ff91e 100644 --- a/test/IRGen/partial_apply_objc.sil +++ b/test/IRGen/partial_apply_objc.sil @@ -48,7 +48,7 @@ bb0(%0 : $ObjCClass): return %0 : $ObjCClass } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @indirect_partial_apply(i8*, %swift.refcounted*, i64) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @indirect_partial_apply(i8* %0, %swift.refcounted* %1, i64 %2) {{.*}} { // CHECK: entry: // CHECK: [[T0:%.*]] = bitcast i8* %0 to void (i64, %swift.refcounted*)* // CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), i64 40, i64 7) @@ -63,7 +63,7 @@ bb0(%0 : $ObjCClass): // CHECK: [[RET:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* [[INDIRECT_PARTIAL_APPLY_STUB:@"\$sTA[A-Za-z0-9_]*"]] to i8*), %swift.refcounted* undef }, %swift.refcounted* [[OBJ]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[RET]] // CHECK: } -// CHECK: define internal swiftcc void [[INDIRECT_PARTIAL_APPLY_STUB]](%swift.refcounted* swiftself) {{.*}} { +// CHECK: define internal swiftcc void [[INDIRECT_PARTIAL_APPLY_STUB]](%swift.refcounted* swiftself %0) {{.*}} { // CHECK: entry: // CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* %0 to [[DATA_TYPE]] // CHECK: [[X_ADDR:%.*]] = getelementptr inbounds [[DATA_TYPE]], [[DATA_TYPE]]* %1, i32 0, i32 1 @@ -83,7 +83,7 @@ entry(%f : $@callee_owned (Builtin.Word) -> (), %x : $Builtin.Word): return %p : $@callee_owned () -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @objc_partial_apply(%T18partial_apply_objc9ObjCClassC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @objc_partial_apply(%T18partial_apply_objc9ObjCClassC* %0) {{.*}} { // CHECK: entry: // CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.2, i32 0, i32 2), i64 24, i64 7) // CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* [[OBJ]] to [[DATA_TYPE:<{ %swift.refcounted, %T18partial_apply_objc9ObjCClassC\* }>]]* @@ -92,7 +92,7 @@ entry(%f : $@callee_owned (Builtin.Word) -> (), %x : $Builtin.Word): // CHECK: [[RET:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (i64, %swift.refcounted*)* [[OBJC_PARTIAL_APPLY_STUB:@"\$sTa[A-Za-z0-9_]*"]] to i8*), %swift.refcounted* undef }, %swift.refcounted* [[OBJ]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[RET]] // CHECK: } -// CHECK: define internal swiftcc void [[OBJC_PARTIAL_APPLY_STUB]](i64, %swift.refcounted* swiftself) {{.*}} { +// CHECK: define internal swiftcc void [[OBJC_PARTIAL_APPLY_STUB]](i64 %0, %swift.refcounted* swiftself %1) {{.*}} { // CHECK: entry: // CHECK-NOT: swift_retain // CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* %1 to [[DATA_TYPE]]* @@ -115,7 +115,7 @@ entry(%c : $ObjCClass): return %p : $@callee_owned (Int) -> () } -// CHECK-LABEL: define{{.*}} { i8*, %swift.refcounted* } @objc_partial_apply_indirect_sil_argument(%T18partial_apply_objc9ObjCClassC*) {{.*}} +// CHECK-LABEL: define{{.*}} { i8*, %swift.refcounted* } @objc_partial_apply_indirect_sil_argument(%T18partial_apply_objc9ObjCClassC* %0) {{.*}} // CHECK: [[CTX:%.*]] = call noalias %swift.refcounted* @swift_allocObject // CHECK: [[CTX_ADDR:%.*]] = bitcast %swift.refcounted* [[CTX]] to [[CTXTYPE:<{ %swift.refcounted, %T18partial_apply_objc9ObjCClassC\* }>]]* // CHECK: [[SELF_ADDR:%.*]] = getelementptr inbounds [[CTXTYPE]], [[CTXTYPE]]* [[CTX_ADDR]], i32 0, i32 1 @@ -123,7 +123,7 @@ entry(%c : $ObjCClass): // CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (double, double, double, double, %swift.refcounted*)* [[OBJC_PARTIAL_APPLY_STUB2:@"\$sTa[A-Za-z0-9_.]*"]] to i8*), %swift.refcounted* undef }, %swift.refcounted* [[CTX]], 1 // CHECK: ret { i8*, %swift.refcounted* } [[CLOSURE]] // CHECK:} -// CHECK: define internal swiftcc void [[OBJC_PARTIAL_APPLY_STUB2]](double, double, double, double, %swift.refcounted* +// CHECK: define internal swiftcc void [[OBJC_PARTIAL_APPLY_STUB2]](double %0, double %1, double %2, double %3, %swift.refcounted* // CHECK: [[TMP:%.*]] = alloca %TSo6NSRectV // CHECK: [[ORIGIN:%.*]] = getelementptr inbounds %TSo6NSRectV, %TSo6NSRectV* [[TMP]] // CHECK: [[ORIGINX:%.*]] = getelementptr inbounds %TSo7NSPointV, %TSo7NSPointV* [[ORIGIN]] @@ -136,10 +136,10 @@ entry(%c : $ObjCClass): return %p : $@callee_owned (NSRect) -> () } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @objc_partial_apply_consumes_self(%T18partial_apply_objc9ObjCClassC*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @objc_partial_apply_consumes_self(%T18partial_apply_objc9ObjCClassC* %0) {{.*}} { // CHECK: bitcast %swift.refcounted* {{%.*}} to [[DATA_TYPE:<{ %swift.refcounted, %T18partial_apply_objc9ObjCClassC\* }>]]* // CHECK: insertvalue {{.*}} [[OBJC_CONSUMES_SELF_PARTIAL_APPLY_STUB:@"\$sTa[A-Za-z0-9_.]*"]] -// CHECK: define internal swiftcc %T18partial_apply_objc9ObjCClassC* [[OBJC_CONSUMES_SELF_PARTIAL_APPLY_STUB]](%swift.refcounted* swiftself) {{.*}} { +// CHECK: define internal swiftcc %T18partial_apply_objc9ObjCClassC* [[OBJC_CONSUMES_SELF_PARTIAL_APPLY_STUB]](%swift.refcounted* swiftself %0) {{.*}} { // CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* %0 to [[DATA_TYPE]]* // CHECK: [[X_ADDR:%.*]] = getelementptr inbounds [[DATA_TYPE]], [[DATA_TYPE]]* [[DATA_ADDR]], i32 0, i32 1 // CHECK: [[SELF:%.*]] = load %T18partial_apply_objc9ObjCClassC*, %T18partial_apply_objc9ObjCClassC** [[X_ADDR]], align 8 @@ -167,9 +167,9 @@ entry(%x : $Int): return %v : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @dynamic_lookup_br_partial_apply(%objc_object*) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @dynamic_lookup_br_partial_apply(%objc_object* %0) {{.*}} { // CHECK: phi i8* [ bitcast (void (i64)* @dummy to i8*), {{%.*}} ], [ bitcast (void (i64, %swift.refcounted*)* [[DYNAMIC_LOOKUP_BR_PARTIAL_APPLY_STUB:@"\$sTa[A-Za-z0-9_.]*"]] to i8*), {{%.*}} ] -// CHECK: define internal swiftcc void [[DYNAMIC_LOOKUP_BR_PARTIAL_APPLY_STUB]](i64, %swift.refcounted* swiftself) {{.*}} { +// CHECK: define internal swiftcc void [[DYNAMIC_LOOKUP_BR_PARTIAL_APPLY_STUB]](i64 %0, %swift.refcounted* swiftself %1) {{.*}} { // CHECK: load i8*, i8** @"\01L_selector(methodWithX:)", align 8 sil @dynamic_lookup_br_partial_apply : $@convention(thin) (Builtin.AnyObject) -> @callee_owned (Int) -> () { @@ -200,7 +200,7 @@ entry(%c : $Gizmo): return %g : $@callee_owned () -> () } -// CHECK: define internal swiftcc void @"$sTa.17"(i64, i64, i64, %swift.refcounted* swiftself) +// CHECK: define internal swiftcc void @"$sTa.17"(i64 %0, i64 %1, i64 %2, %swift.refcounted* swiftself %3) // CHECK: [[TMPCOERCE:%.*]] = alloca { i64, i64, i64 } // CHECK: [[INDIRECTTEMP:%.*]] = alloca %TSo3FobV // CHECK: [[ADDR:%.*]] = getelementptr inbounds { i64, i64, i64 }, { i64, i64, i64 }* [[TMPCOERCE]], i32 0, i32 0 @@ -240,7 +240,7 @@ entry(%c : $ObjCClass): return %p : $@callee_guaranteed (Int) -> () } -// CHECK-LABEL: define {{.*}}swiftcc void @"$sTa.20"(i64, %swift.refcounted* swiftself) +// CHECK-LABEL: define {{.*}}swiftcc void @"$sTa.20"(i64 %0, %swift.refcounted* swiftself %1) // CHECK: entry: // CHECK-NOT: retain // CHECK-NOT: release @@ -263,7 +263,7 @@ entry(%c : $Gizmo): return %p : $@callee_guaranteed (Fob) -> () } -// CHECK-LABEL: define {{.*}}swiftcc void @"$sTa.23"(i64, i64, i64, %swift.refcounted* swiftself) +// CHECK-LABEL: define {{.*}}swiftcc void @"$sTa.23"(i64 %0, i64 %1, i64 %2, %swift.refcounted* swiftself %3) // CHECK: entry: // CHECK-NOT: retain // CHECK-NOT: release diff --git a/test/IRGen/preserve_exclusivity.swift b/test/IRGen/preserve_exclusivity.swift index 9b74ee4c3b567..72fb40e3efd49 100644 --- a/test/IRGen/preserve_exclusivity.swift +++ b/test/IRGen/preserve_exclusivity.swift @@ -28,7 +28,7 @@ public func endAccess(_ address: Builtin.RawPointer) { Builtin.endUnpairedAccess(address) } -// CHECK-LABEL: define {{.*}}swiftcc void @"$s20preserve_exclusivity10readAccessyyBp_xmtlF"(i8*, %swift.type*{{.*}}, %swift.type*{{.*}} %T1) +// CHECK-LABEL: define {{.*}}swiftcc void @"$s20preserve_exclusivity10readAccessyyBp_xmtlF"(i8* %0, %swift.type*{{.*}}, %swift.type*{{.*}} %T1) // CHECK: call void @swift_beginAccess // CHECK: ret void public func readAccess(_ address: Builtin.RawPointer, _ ty1: T1.Type) { @@ -38,7 +38,7 @@ public func readAccess(_ address: Builtin.RawPointer, _ ty1: T1.Type) { // Make sure testAccess properly inlines in our functions. // -// CHECK-LABEL: define {{.*}}swiftcc void @"$s20preserve_exclusivity10testAccessyyBpF"(i8*) +// CHECK-LABEL: define {{.*}}swiftcc void @"$s20preserve_exclusivity10testAccessyyBpF"(i8* %0) // CHECK: call swiftcc void @marker1 // CHECK: call void @swift_beginAccess // CHECK: call swiftcc void @marker2 diff --git a/test/IRGen/prespecialized-metadata/struct-fileprivate-inmodule-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-fileprivate-inmodule-1argument-1distinct_use.swift index 628394450cbee..58452af103804 100644 --- a/test/IRGen/prespecialized-metadata/struct-fileprivate-inmodule-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-fileprivate-inmodule-1argument-1distinct_use.swift @@ -41,7 +41,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define internal swiftcc %swift.metadata_response @"$s4main5Value[[UNIQUE_ID_1]]VMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define internal swiftcc %swift.metadata_response @"$s4main5Value[[UNIQUE_ID_1]]VMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_LABEL:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-0argument-within-class-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-0argument-within-class-1argument-1distinct_use.swift index da95112e4b7a0..33f41d29d11bb 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-0argument-within-class-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-0argument-within-class-1argument-1distinct_use.swift @@ -43,7 +43,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-0distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-0distinct_use.swift index 93037c028fdc8..51a0189378ab6 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-0distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-0distinct_use.swift @@ -22,7 +22,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: {{%[0-9]+}} = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[ERASED_TYPE]], i8* undef, i8* undef, %swift.type_descriptor* bitcast (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s4main5ValueVMn" to %swift.type_descriptor*)) #{{[0-9]+}} diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance-1distinct_use.swift index 25b929ec02616..052c1695d9d73 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance-1distinct_use.swift @@ -47,7 +47,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, i8** %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TABLE:%[0-9]+]] = bitcast i8** %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance_stdlib_equatable-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance_stdlib_equatable-1distinct_use.swift index dd97d2f22c53d..bc6837152f596 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance_stdlib_equatable-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1conformance_stdlib_equatable-1distinct_use.swift @@ -26,7 +26,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, i8** %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_CONFORMANCE:%[0-9]+]] = bitcast i8** %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_generic_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_generic_use.swift index 952dd10b23538..a8f1e8f5f398c 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_generic_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_generic_use.swift @@ -51,7 +51,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5OuterVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5OuterVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_LABEL:[0-9]+]] @@ -116,9 +116,9 @@ doit() // CHECK: } // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5InnerVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5InnerVMa"([[INT]] %0, %swift.type* [[TYPE:%[0-9]+]]) #{{[0-9]+}} { // CHECK: entry: -// CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* +// CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* [[TYPE]] to i8* // CHECK: br label %[[TYPE_COMPARISON_LABEL:[0-9]+]] // CHECK: [[TYPE_COMPARISON_LABEL]]: // CHECK: [[EQUAL_TYPE:%[0-9]+]] = icmp eq i8* bitcast (%swift.type* @"$sSiN" to i8*), [[ERASED_TYPE]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_use.swift index 180109ba53cfd..a3faea5560a2a 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-1distinct_use.swift @@ -41,7 +41,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_LABEL:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2conformance-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2conformance-1distinct_use.swift index 601dbd4a2863a..0e045a7c2e3d2 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2conformance-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2conformance-1distinct_use.swift @@ -51,7 +51,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, i8**, i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, i8** %2, i8** %3) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TABLE_1:%[0-9]+]] = bitcast i8** %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2distinct_use.swift index a2cb96b957a43..2e669de9bbfb6 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-2distinct_use.swift @@ -60,7 +60,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3conformance-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3conformance-1distinct_use.swift index cba697ddf2ab2..850609499c81b 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3conformance-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3conformance-1distinct_use.swift @@ -55,7 +55,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, i8** %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_ARGUMENT_BUFFER:%[0-9]+]] = bitcast i8** %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3distinct_use.swift index 80b801f3d114f..ee3e2f8da3be1 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-3distinct_use.swift @@ -81,7 +81,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4conformance-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4conformance-1distinct_use.swift index 517da257dfe9a..f5b24fae358ec 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4conformance-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4conformance-1distinct_use.swift @@ -59,7 +59,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, i8** %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_ARGUMENT_BUFFER:%[0-9]+]] = bitcast i8** %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4distinct_use.swift index 1cf7e89ba4ee0..bc0bb444229d7 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-4distinct_use.swift @@ -82,7 +82,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5conformance-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5conformance-1distinct_use.swift index de3c5c0822d66..ac418a7169ee2 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5conformance-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5conformance-1distinct_use.swift @@ -63,7 +63,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], i8**) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, i8** %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_ARGUMENT_BUFFER:%[0-9]+]] = bitcast i8** %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5distinct_use.swift index 73156db3c7fa4..cbc5fc78518b3 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-5distinct_use.swift @@ -120,7 +120,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-clang_node-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-clang_node-1distinct_use.swift index a98483281477b..1ed83c22d1d89 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-clang_node-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-clang_node-1distinct_use.swift @@ -35,7 +35,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: {{%[0-9]+}} = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[ERASED_TYPE]], i8* undef, i8* undef, %swift.type_descriptor* bitcast (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s4main5ValueVMn" to %swift.type_descriptor*)) #{{[0-9]+}} diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-class-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-class-1argument-1distinct_use.swift index b3c093221f6c9..ae6223b3a3165 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-class-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-class-1argument-1distinct_use.swift @@ -45,7 +45,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-enum-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-enum-1argument-1distinct_use.swift index 106d42451dbf5..503ed4e1651ba 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-enum-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-enum-1argument-1distinct_use.swift @@ -45,7 +45,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceO5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceO5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-1argument-1distinct_use.swift index 9d73b22b468e1..aa9311c3ab8a4 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-1argument-1distinct_use.swift @@ -45,7 +45,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceV5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceV5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-2argument-constrained_extension-equal_arguments-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-2argument-constrained_extension-equal_arguments-1distinct_use.swift index 315affc0dda6d..d6ee139387b43 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-2argument-constrained_extension-equal_arguments-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-1argument-within-struct-2argument-constrained_extension-equal_arguments-1distinct_use.swift @@ -77,10 +77,10 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceVAAq_RszrlE5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceVAAq_RszrlE5ValueVMa"([[INT]] %0, %swift.type* [[TYPE_1:%[0-9]+]], %swift.type* [[TYPE_2:%[0-9]+]]) #{{[0-9]+}} { // CHECK: entry: -// CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* -// CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* +// CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* [[TYPE_1]] to i8* +// CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* [[TYPE_2]] to i8* // CHECK: br label %[[TYPE_COMPARISON_1:[0-9]+]] // CHECK: [[TYPE_COMPARISON_1]]: // CHECK: [[EQUAL_TYPE_1_1:%[0-9]+]] = icmp eq i8* bitcast (%swift.type* @"$sSiN" to i8*), [[ERASED_TYPE_1]] diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-0distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-0distinct_use.swift index 32ec219a0435a..e08c3b67a4f35 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-0distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-0distinct_use.swift @@ -23,7 +23,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-1distinct_use.swift index 90e582c84578a..19812a5d39010 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-1distinct_use.swift @@ -43,7 +43,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-2distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-2distinct_use.swift index 6c64ba8f00e81..a0fea9d939def 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-2distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-2distinct_use.swift @@ -64,7 +64,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-3distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-3distinct_use.swift index 9b204443c6c82..a099cbd7719a0 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-3distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-3distinct_use.swift @@ -85,7 +85,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-4distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-4distinct_use.swift index ccbf44cd9c5a6..1f0e579d7508e 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-4distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-4distinct_use.swift @@ -106,7 +106,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-5distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-5distinct_use.swift index d70ee5ba48434..8fae723ea7911 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-5distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-5distinct_use.swift @@ -108,7 +108,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-within-class-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-within-class-1argument-1distinct_use.swift index 12d7298d34bfc..d9fd8453a2c3b 100644 --- a/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-within-class-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-inmodule-2argument-within-class-1argument-1distinct_use.swift @@ -45,7 +45,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]], %swift.type*, %swift.type*, %swift.type*) #{{[0-9]+}} { +// CHECK: define hidden swiftcc %swift.metadata_response @"$s4main9NamespaceC5ValueVMa"([[INT]] %0, %swift.type* %1, %swift.type* %2, %swift.type* %3) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE_1:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: [[ERASED_TYPE_2:%[0-9]+]] = bitcast %swift.type* %2 to i8* diff --git a/test/IRGen/prespecialized-metadata/struct-public-inmodule-1argument-1distinct_use.swift b/test/IRGen/prespecialized-metadata/struct-public-inmodule-1argument-1distinct_use.swift index dd88e25a4216e..1cf8550fb63f3 100644 --- a/test/IRGen/prespecialized-metadata/struct-public-inmodule-1argument-1distinct_use.swift +++ b/test/IRGen/prespecialized-metadata/struct-public-inmodule-1argument-1distinct_use.swift @@ -42,7 +42,7 @@ func doit() { doit() // CHECK: ; Function Attrs: noinline nounwind readnone -// CHECK: define{{( protected| dllexport)?}} swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]], %swift.type*) #{{[0-9]+}} { +// CHECK: define{{( protected| dllexport)?}} swiftcc %swift.metadata_response @"$s4main5ValueVMa"([[INT]] %0, %swift.type* %1) #{{[0-9]+}} { // CHECK: entry: // CHECK: [[ERASED_TYPE:%[0-9]+]] = bitcast %swift.type* %1 to i8* // CHECK: br label %[[TYPE_COMPARISON_LABEL:[0-9]+]] diff --git a/test/IRGen/protocol_resilience.sil b/test/IRGen/protocol_resilience.sil index a1ecec33db9c1..814a26f06e2db 100644 --- a/test/IRGen/protocol_resilience.sil +++ b/test/IRGen/protocol_resilience.sil @@ -135,7 +135,7 @@ protocol InternalProtocol { // CHECK-SAME: } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultC(%swift.opaque* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultC(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @defaultC : $@convention(witness_method: ResilientProtocol) (@in_guaranteed Self) -> () { bb0(%0 : $*Self): @@ -146,7 +146,7 @@ bb0(%0 : $*Self): return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultD(%swift.opaque* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultD(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @defaultD : $@convention(witness_method: ResilientProtocol) (@in_guaranteed Self) -> () { @@ -187,7 +187,7 @@ bb0(%0 : $*Self): } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultE(%swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultE(%swift.type* swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @defaultE : $@convention(witness_method: ResilientProtocol) (@thick Self.Type) -> () { @@ -228,7 +228,7 @@ bb0(%0 : $@thick Self.Type): } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultF(%swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @defaultF(%swift.type* swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @defaultF : $@convention(witness_method: ResilientProtocol) (@thick Self.Type) -> () { @@ -267,7 +267,7 @@ struct ConformingStruct : ResilientProtocol { static func defaultF() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @noDefaultA(%T19protocol_resilience16ConformingStructV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @noDefaultA(%T19protocol_resilience16ConformingStructV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @noDefaultA : $@convention(witness_method: ResilientProtocol) (@in_guaranteed ConformingStruct) -> () { @@ -287,7 +287,7 @@ bb0(%0 : $*ConformingStruct): } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @noDefaultB(%T19protocol_resilience16ConformingStructV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @noDefaultB(%T19protocol_resilience16ConformingStructV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK-NEXT: entry: sil @noDefaultB : $@convention(witness_method: ResilientProtocol) (@in_guaranteed ConformingStruct) -> () { @@ -325,14 +325,14 @@ sil_witness_table ConformingStruct : ResilientProtocol module protocol_resilienc // Make sure resilient conformances are accessed with an accessor function // -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomething(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.OtherResilientProtocol) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomething(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.OtherResilientProtocol) sil @doSomething : $@convention(thin) (@in T) -> () { bb0(%0 : $*T): %result = tuple () return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingType(%T19protocol_resilience23ResilientConformingTypeV* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingType(%T19protocol_resilience23ResilientConformingTypeV* noalias nocapture %0) sil @passConformingType : $@convention(thin) (@in ResilientConformingType) -> () { bb0(%0 : $*ResilientConformingType): @@ -383,14 +383,14 @@ sil_witness_table AnotherConformingStruct : RefinesOtherResilientProtocol module sil_witness_table hidden AnotherConformingStruct: OtherResilientProtocol module protocol_resilience { } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomethingRefined(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.RefinesOtherResilientProtocol) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomethingRefined(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.RefinesOtherResilientProtocol) sil @doSomethingRefined : $@convention(thin) (@in T) -> () { bb0(%0 : $*T): %result = tuple () return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingTypeRefined(%T19protocol_resilience23AnotherConformingStructV* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingTypeRefined(%T19protocol_resilience23AnotherConformingStructV* noalias nocapture %0) sil @passConformingTypeRefined : $@convention(thin) (@in AnotherConformingStruct) -> () { bb0(%0 : $*AnotherConformingStruct): @@ -427,14 +427,14 @@ sil_witness_table ConformsWithResilientAssoc : HasResilientAssoc module protocol associated_type T: ResilientConformingType } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomethingAssoc(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.HasResilientAssoc) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doSomethingAssoc(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.HasResilientAssoc) sil @doSomethingAssoc : $@convention(thin) (@in T) -> () { bb0(%0 : $*T): %result = tuple () return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingTypeAssoc(%T19protocol_resilience26ConformsWithResilientAssocV* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @passConformingTypeAssoc(%T19protocol_resilience26ConformsWithResilientAssocV* noalias nocapture %0) sil @passConformingTypeAssoc : $@convention(thin) (@in ConformsWithResilientAssoc) -> () { bb0(%0 : $*ConformsWithResilientAssoc): diff --git a/test/IRGen/protocol_resilience_descriptors.swift b/test/IRGen/protocol_resilience_descriptors.swift index b780c41eb4198..3662ff601f9a4 100644 --- a/test/IRGen/protocol_resilience_descriptors.swift +++ b/test/IRGen/protocol_resilience_descriptors.swift @@ -98,7 +98,7 @@ public struct ConformsToDerived : ResilientDerivedProtocol { // Resilient protocol usage // ---------------------------------------------------------------------------- -// CHECK-USAGE: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s31protocol_resilience_descriptors17assocTypeMetadatay1TQzmxm010resilient_A024ProtocolWithRequirementsRzlF"(%swift.type*, %swift.type* [[PWD:%.*]], i8** [[WTABLE:%.*]]) +// CHECK-USAGE: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s31protocol_resilience_descriptors17assocTypeMetadatay1TQzmxm010resilient_A024ProtocolWithRequirementsRzlF"(%swift.type* %0, %swift.type* [[PWD:%.*]], i8** [[WTABLE:%.*]]) public func assocTypeMetadata(_: PWR.Type) -> PWR.T.Type { // CHECK-USAGE: call swiftcc %swift.metadata_response @swift_getAssociatedTypeWitness([[INT]] 0, i8** %PWR.ProtocolWithRequirements, %swift.type* %PWR, %swift.protocol_requirement* @"$s18resilient_protocol24ProtocolWithRequirementsTL", %swift.protocol_requirement* @"$s1T18resilient_protocol24ProtocolWithRequirementsPTl") return PWR.T.self diff --git a/test/IRGen/protocol_resilience_thunks.swift b/test/IRGen/protocol_resilience_thunks.swift index 79da17be84f1e..dd0005a38bb6e 100644 --- a/test/IRGen/protocol_resilience_thunks.swift +++ b/test/IRGen/protocol_resilience_thunks.swift @@ -18,7 +18,7 @@ import resilient_protocol // CHECK-LABEL: @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvsTq" ={{( dllexport)?}}{{( protected)?}} alias %swift.protocol_requirement, getelementptr inbounds (<{{.*}}>* @"$s26protocol_resilience_thunks19MyResilientProtocolMp", i32 0, i32 12) // CHECK-LABEL: @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvMTq" ={{( dllexport)?}}{{( protected)?}} alias %swift.protocol_requirement, getelementptr inbounds (<{{.*}}>* @"$s26protocol_resilience_thunks19MyResilientProtocolMp", i32 0, i32 13) -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks26callResilientWitnessMethodyyx010resilient_A00E12BaseProtocolRzlF"(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.ResilientBaseProtocol) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks26callResilientWitnessMethodyyx010resilient_A00E12BaseProtocolRzlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T, i8** %T.ResilientBaseProtocol) // CHECK: call swiftcc [[INT]] @"$s18resilient_protocol21ResilientBaseProtocolP11requirementSiyFTj"(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %T, i8** %T.ResilientBaseProtocol) // CHECK: ret void public func callResilientWitnessMethod(_ value: T) { @@ -38,56 +38,56 @@ public protocol MyResilientProtocol { var property: Bool { get set } } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP11returnsVoid1xySb_tFTj"(i1, %swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP11returnsVoid1xySb_tFTj"(i1 %0, %swift.opaque* noalias nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK: [[WITNESS_GEP:%.*]] = getelementptr inbounds i8*, i8** %3, i32 1 // CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_GEP]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to void (i1, %swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: call swiftcc void [[FN]](i1 %0, %swift.opaque* noalias nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK-NEXT: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s26protocol_resilience_thunks19MyResilientProtocolP11returnsBoolSbyFTj"(%swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s26protocol_resilience_thunks19MyResilientProtocolP11returnsBoolSbyFTj"(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %1, i8** %2) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %2, i32 2 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to i1 (%swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: [[RESULT:%.*]] = call swiftcc i1 [[FN]](%swift.opaque* noalias nocapture swiftself %0, %swift.type* %1, i8** %2) // CHECK-NEXT: ret i1 [[RESULT]] -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP10returnsAnyypyFTj"(%Any* noalias nocapture sret, %swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP10returnsAnyypyFTj"(%Any* noalias nocapture sret %0, %swift.opaque* noalias nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %3, i32 3 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to void (%Any*, %swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: call swiftcc void [[FN]](%Any* noalias nocapture sret %0, %swift.opaque* noalias nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK-NEXT: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP12throwingFuncyyKFTj"(%swift.opaque* noalias nocapture swiftself, %swift.error**{{( noalias nocapture( swifterror)? dereferenceable\(.\))?}}, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP12throwingFuncyyKFTj"(%swift.opaque* noalias nocapture swiftself %0, %swift.error**{{( noalias nocapture( swifterror)? dereferenceable\(.\))?}} %1, %swift.type* %2, i8** %3) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %3, i32 4 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to void (%swift.opaque*, %swift.error**, %swift.type*, i8**)* // CHECK-NEXT: call swiftcc void [[FN]](%swift.opaque* noalias nocapture swiftself %0, %swift.error**{{( noalias nocapture( swifterror)? dereferenceable\(.\))?}} %1, %swift.type* %2, i8** %3) // CHECK-NEXT: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP11genericFuncyqd__qd__lFTj"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type*, %swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP11genericFuncyqd__qd__lFTj"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %2, %swift.opaque* noalias nocapture swiftself %3, %swift.type* %4, i8** %5) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %5, i32 5 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to void (%swift.opaque*, %swift.opaque*, %swift.type*, %swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: call swiftcc void [[FN]](%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.type* %2, %swift.opaque* noalias nocapture swiftself %3, %swift.type* %4, i8** %5) // CHECK-NEXT: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvgTj"(%swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvgTj"(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %1, i8** %2) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %2, i32 6 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to i1 (%swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: [[RESULT:%.*]] = call swiftcc i1 %5(%swift.opaque* noalias nocapture swiftself %0, %swift.type* %1, i8** %2) // CHECK-NEXT: ret i1 [[RESULT]] -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvsTj"(i1, %swift.opaque* nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvsTj"(i1 %0, %swift.opaque* nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %3, i32 7 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to void (i1, %swift.opaque*, %swift.type*, i8**)* // CHECK-NEXT: call swiftcc void [[FN]](i1 %0, %swift.opaque* nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK-NEXT: ret void -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %TSb* } @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvMTj"(i8* noalias dereferenceable({{16|32}}), %swift.opaque* nocapture swiftself, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %TSb* } @"$s26protocol_resilience_thunks19MyResilientProtocolP8propertySbvMTj"(i8* noalias dereferenceable({{16|32}}) %0, %swift.opaque* nocapture swiftself %1, %swift.type* %2, i8** %3) // CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** %3, i32 8 // CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]] // CHECK-NEXT: [[FN:%.*]] = bitcast i8* [[WITNESS]] to { i8*, %TSb* } (i8*, %swift.opaque*, %swift.type*, i8**)* diff --git a/test/IRGen/protocol_with_superclass.sil b/test/IRGen/protocol_with_superclass.sil index e4adade3b87c8..27441e149fc2a 100644 --- a/test/IRGen/protocol_with_superclass.sil +++ b/test/IRGen/protocol_with_superclass.sil @@ -25,8 +25,8 @@ class SubDerived : Derived {} class MoreDerived : Concrete, SubProto {} -// CHECK-objc-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC*, {{.*}} { -// CHECK-native-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC*, %swift.refcounted*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**) {{.*}} { +// CHECK-objc-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC* %0, {{.*}} { +// CHECK-native-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC* %0, %swift.refcounted* %1, i8** %2, %T24protocol_with_superclass8ConcreteC* %3, i8** %4, %T24protocol_with_superclass8ConcreteC* %5, i8** %6, %T24protocol_with_superclass8ConcreteC* %7, i8** %8) {{.*}} { sil hidden @checkExistentialDowncast : $@convention(thin) (@owned Concrete, @owned SuperProto, @owned SuperProto & Concrete, @owned ProtoRefinesClass, @owned SubProto) -> () { bb0(%0 : $Concrete, %1 : $SuperProto, %2 : $SuperProto & Concrete, %3 : $ProtoRefinesClass, %4 : $SubProto): diff --git a/test/IRGen/protocol_with_superclass_where_clause.sil b/test/IRGen/protocol_with_superclass_where_clause.sil index 1a158a08c7336..ff0ea50e5fe89 100644 --- a/test/IRGen/protocol_with_superclass_where_clause.sil +++ b/test/IRGen/protocol_with_superclass_where_clause.sil @@ -25,8 +25,8 @@ class SubDerived : Derived {} class MoreDerived : Concrete, SubProto {} -// CHECK-objc-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC*, {{.*}} { -// CHECK-native-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC*, %swift.refcounted*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**, %T24protocol_with_superclass8ConcreteC*, i8**) {{.*}} { +// CHECK-objc-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC* %0, {{.*}} { +// CHECK-native-LABEL: define hidden swiftcc void @checkExistentialDowncast(%T24protocol_with_superclass8ConcreteC* %0, %swift.refcounted* %1, i8** %2, %T24protocol_with_superclass8ConcreteC* %3, i8** %4, %T24protocol_with_superclass8ConcreteC* %5, i8** %6, %T24protocol_with_superclass8ConcreteC* %7, i8** %8) {{.*}} { sil hidden @checkExistentialDowncast : $@convention(thin) (@owned Concrete, @owned SuperProto, @owned SuperProto & Concrete, @owned ProtoRefinesClass, @owned SubProto) -> () { bb0(%0 : $Concrete, %1 : $SuperProto, %2 : $SuperProto & Concrete, %3 : $ProtoRefinesClass, %4 : $SubProto): diff --git a/test/IRGen/runtime_calling_conventions.swift b/test/IRGen/runtime_calling_conventions.swift index 20aa9f0c778db..68243805424d4 100644 --- a/test/IRGen/runtime_calling_conventions.swift +++ b/test/IRGen/runtime_calling_conventions.swift @@ -7,11 +7,11 @@ public class C { } -// CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC*) +// CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC* %0) // Check that runtime functions use a proper calling convention. // CHECK-NOT: call void {{.*}} @swift_release -// OPT-CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC* nocapture) +// OPT-CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swiftcc void @"$s27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC* nocapture %0) // Check that runtime functions use a proper calling convention. // OPT-CHECK-NOT: tail call void @swift_release diff --git a/test/IRGen/select_enum.sil b/test/IRGen/select_enum.sil index 7ab33397c812d..d0c79432a544f 100644 --- a/test/IRGen/select_enum.sil +++ b/test/IRGen/select_enum.sil @@ -7,7 +7,7 @@ enum SinglePayloadSingleEmpty { case DataCase(Builtin.Word) } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @select_enum_SinglePayloadSingleEmpty(%T11select_enum013SinglePayloadC5EmptyO* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @select_enum_SinglePayloadSingleEmpty(%T11select_enum013SinglePayloadC5EmptyO* noalias nocapture dereferenceable({{.*}}) %0) sil @select_enum_SinglePayloadSingleEmpty : $@convention(thin) (@in SinglePayloadSingleEmpty) -> () { bb0(%0 : $*SinglePayloadSingleEmpty): %1 = load %0 : $*SinglePayloadSingleEmpty @@ -79,7 +79,7 @@ enum NoPayloadSingleton { case One } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @testOptionalOfNoPayloadSingleton(i8) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @testOptionalOfNoPayloadSingleton(i8 %0) sil @testOptionalOfNoPayloadSingleton : $@convention(thin) (MyOptional) -> Builtin.Int1 { bb0(%0 : $MyOptional): // CHECK: [[NATIVECCTRUNC:%.*]] = trunc i8 %0 to i1 diff --git a/test/IRGen/sil_generic_witness_methods.swift b/test/IRGen/sil_generic_witness_methods.swift index 662963bb528a5..4f4ad9cf75b9a 100644 --- a/test/IRGen/sil_generic_witness_methods.swift +++ b/test/IRGen/sil_generic_witness_methods.swift @@ -13,7 +13,7 @@ protocol P { struct S {} -// CHECK-LABEL: define hidden swiftcc void @"$s27sil_generic_witness_methods05call_D0{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T, %swift.type* %U, i8** %T.P) +// CHECK-LABEL: define hidden swiftcc void @"$s27sil_generic_witness_methods05call_D0{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture %1, %swift.type* %T, %swift.type* %U, i8** %T.P) func call_methods(_ x: T, y: S, z: U) { // CHECK: [[STATIC_METHOD_ADDR:%.*]] = getelementptr inbounds i8*, i8** %T.P, i32 2 // CHECK: [[STATIC_METHOD_PTR:%.*]] = load i8*, i8** [[STATIC_METHOD_ADDR]], align 8 @@ -38,7 +38,7 @@ func call_methods(_ x: T, y: S, z: U) { x.generic_method(z) } -// CHECK-LABEL: define hidden swiftcc void @"$s27sil_generic_witness_methods017call_existential_D0{{[_0-9a-zA-Z]*}}F"(%T27sil_generic_witness_methods1PP* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define hidden swiftcc void @"$s27sil_generic_witness_methods017call_existential_D0{{[_0-9a-zA-Z]*}}F"(%T27sil_generic_witness_methods1PP* noalias nocapture dereferenceable({{.*}}) %0) func call_existential_methods(_ x: P, y: S) { // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T27sil_generic_witness_methods1PP, %T27sil_generic_witness_methods1PP* [[X:%0]], i32 0, i32 1 // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]], align 8 diff --git a/test/IRGen/sil_generic_witness_methods_objc.swift b/test/IRGen/sil_generic_witness_methods_objc.swift index 460a0cd387443..9d7c652b567d2 100644 --- a/test/IRGen/sil_generic_witness_methods_objc.swift +++ b/test/IRGen/sil_generic_witness_methods_objc.swift @@ -9,7 +9,7 @@ func method() } -// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_E7_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_E7_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) {{.*}} { // CHECK: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(method)", align 8 // CHECK: [[CAST:%.*]] = bitcast %objc_object* %0 to [[SELFTYPE:%?.*]]* // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[SELFTYPE]]*, i8*)*)([[SELFTYPE]]* [[CAST]], i8* [[SEL]]) @@ -17,13 +17,13 @@ func call_objc_method(_ x: T) { x.method() } -// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_f1_E7_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_f1_E7_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) {{.*}} { // CHECK: call swiftcc void @"$s32sil_generic_witness_methods_objc05call_E7_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0, %swift.type* %T) func call_call_objc_method(_ x: T) { call_objc_method(x) } -// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_E19_existential_method{{[_0-9a-zA-Z]*}}F"(%objc_object*) {{.*}} { +// CHECK-LABEL: define hidden swiftcc void @"$s32sil_generic_witness_methods_objc05call_E19_existential_method{{[_0-9a-zA-Z]*}}F"(%objc_object* %0) {{.*}} { // CHECK: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(method)", align 8 // CHECK: [[CAST:%.*]] = bitcast %objc_object* %0 to [[SELFTYPE:%?.*]]* // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[SELFTYPE]]*, i8*)*)([[SELFTYPE]]* [[CAST]], i8* [[SEL]]) diff --git a/test/IRGen/sil_witness_methods.sil b/test/IRGen/sil_witness_methods.sil index 94c79d3c41835..62dbce92f8465 100644 --- a/test/IRGen/sil_witness_methods.sil +++ b/test/IRGen/sil_witness_methods.sil @@ -27,14 +27,14 @@ struct X {} struct Y {} struct Z {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_concrete_method_witness(%T19sil_witness_methods3FooV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_concrete_method_witness(%T19sil_witness_methods3FooV* noalias nocapture swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) sil @concrete_type_concrete_method_witness : $@convention(witness_method: P) (@in Foo) -> @thick Foo.Type { entry(%x : $*Foo): %m = metatype $@thick Foo.Type return %m : $@thick Foo.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_concrete_method_witness(%T19sil_witness_methods3BarC** noalias nocapture swiftself dereferenceable({{.*}}), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_concrete_method_witness(%T19sil_witness_methods3BarC** noalias nocapture swiftself dereferenceable({{.*}}) %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK: [[T0:%.*]] = bitcast %swift.type* %Self to %swift.type** // CHECK: [[T1:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[T0]], i64 10 // CHECK: %T = load %swift.type*, %swift.type** [[T1]], align 8 @@ -56,7 +56,7 @@ entry(%x : $*Bar): // TODO: %Self Type arg is redundant for static method witness -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_concrete_static_method_witness(%swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_concrete_static_method_witness(%swift.type* swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) sil @concrete_type_concrete_static_method_witness : $@convention(witness_method: P) (@thick Foo.Type) -> @thick Foo.Type { entry(%x : $@thick Foo.Type): %m = metatype $@thick Foo.Type @@ -64,7 +64,7 @@ entry(%x : $@thick Foo.Type): } // The use of %0 or %Self here is irrelevant. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_concrete_static_method_witness(%swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_concrete_static_method_witness(%swift.type* swiftself %0, %swift.type* %Self, i8** %SelfWitnessTable) // CHECK: [[T0:%.*]] = bitcast %swift.type* %Self to %swift.type** // CHECK: [[T1:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[T0]], i64 10 // CHECK: %T = load %swift.type*, %swift.type** [[T1]], align 8 @@ -86,14 +86,14 @@ entry(%x : $@thick Bar.Type): // TODO: %Self Type arg is redundant for class method witness -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_generic_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %T19sil_witness_methods3FooV* noalias nocapture swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_generic_method_witness(%swift.opaque* noalias nocapture %0, %swift.type* %Z, %T19sil_witness_methods3FooV* noalias nocapture swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) sil @concrete_type_generic_method_witness : $@convention(witness_method: P) (@in Z, @in Foo) -> @thick Foo.Type { entry(%z : $*Z, %x : $*Foo): %m = metatype $@thick Foo.Type return %m : $@thick Foo.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_generic_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %T19sil_witness_methods3BarC{{.*}}** noalias nocapture swiftself dereferenceable(8), %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_generic_method_witness(%swift.opaque* noalias nocapture %0, %swift.type* %Z, %T19sil_witness_methods3BarC{{.*}}** noalias nocapture swiftself dereferenceable(8) %1, %swift.type* %Self, i8** %SelfWitnessTable) sil @generic_type_generic_method_witness : $@convention(witness_method: P) (@in Z, @in Bar) -> @thick Bar.Type { entry(%z : $*Z, %x : $*Bar): %t = metatype $@thick T.Type @@ -104,14 +104,14 @@ entry(%z : $*Z, %x : $*Bar): return %m : $@thick Bar.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_generic_static_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @concrete_type_generic_static_method_witness(%swift.opaque* noalias nocapture %0, %swift.type* %Z, %swift.type* swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) sil @concrete_type_generic_static_method_witness : $@convention(witness_method: P) (@in Z, @thick Foo.Type) -> @thick Foo.Type { entry(%z : $*Z, %x : $@thick Foo.Type): %m = metatype $@thick Foo.Type return %m : $@thick Foo.Type } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_generic_static_method_witness(%swift.opaque* noalias nocapture, %swift.type* %Z, %swift.type* swiftself, %swift.type* %Self, i8** %SelfWitnessTable) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @generic_type_generic_static_method_witness(%swift.opaque* noalias nocapture %0, %swift.type* %Z, %swift.type* swiftself %1, %swift.type* %Self, i8** %SelfWitnessTable) sil @generic_type_generic_static_method_witness : $@convention(witness_method: P) (@in Z, @thick Bar.Type) -> @thick Bar.Type { entry(%z : $*Z, %x : $@thick Bar.Type): %t = metatype $@thick T.Type diff --git a/test/IRGen/sil_witness_tables.swift b/test/IRGen/sil_witness_tables.swift index ea742ed8e5991..1f08e29d84a75 100644 --- a/test/IRGen/sil_witness_tables.swift +++ b/test/IRGen/sil_witness_tables.swift @@ -57,14 +57,14 @@ struct Conformer2: Q { func qMethod() {} } -// CHECK-LABEL: define hidden swiftcc void @"$s18sil_witness_tables7erasure1cAA2QQ_pAA9ConformerV_tF"(%T18sil_witness_tables2QQP* noalias nocapture sret) +// CHECK-LABEL: define hidden swiftcc void @"$s18sil_witness_tables7erasure1cAA2QQ_pAA9ConformerV_tF"(%T18sil_witness_tables2QQP* noalias nocapture sret %0) // CHECK: [[WITNESS_TABLE_ADDR:%.*]] = getelementptr inbounds %T18sil_witness_tables2QQP, %T18sil_witness_tables2QQP* %0, i32 0, i32 2 // CHECK-NEXT: store i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* [[CONFORMER_QQ_WITNESS_TABLE:@"\$s.*WP"]], i32 0, i32 0), i8*** [[WITNESS_TABLE_ADDR]], align 8 func erasure(c: Conformer) -> QQ { return c } -// CHECK-LABEL: define hidden swiftcc void @"$s18sil_witness_tables15externalErasure1c0a1_b1_c1_D12_conformance9ExternalP_pAD0G9ConformerV_tF"(%T39sil_witness_tables_external_conformance9ExternalPP* noalias nocapture sret) +// CHECK-LABEL: define hidden swiftcc void @"$s18sil_witness_tables15externalErasure1c0a1_b1_c1_D12_conformance9ExternalP_pAD0G9ConformerV_tF"(%T39sil_witness_tables_external_conformance9ExternalPP* noalias nocapture sret %0) // CHECK: [[WITNESS_TABLE_ADDR:%.*]] = getelementptr inbounds %T39sil_witness_tables_external_conformance9ExternalPP, %T39sil_witness_tables_external_conformance9ExternalPP* %0, i32 0, i32 2 // CHECK-NEXT: store i8** [[EXTERNAL_CONFORMER_EXTERNAL_P_WITNESS_TABLE]], i8*** %2, align 8 func externalErasure(c: ExternalConformer) -> ExternalP { @@ -73,5 +73,5 @@ func externalErasure(c: ExternalConformer) -> ExternalP { // FIXME: why do these have different linkages? -// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s18sil_witness_tables14AssocConformerVMa"(i64) +// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s18sil_witness_tables14AssocConformerVMa"(i64 %0) // CHECK: ret %swift.metadata_response { %swift.type* bitcast (i64* getelementptr inbounds {{.*}} @"$s18sil_witness_tables14AssocConformerVMf", i32 0, i32 1) to %swift.type*), i64 0 } diff --git a/test/IRGen/sil_witness_tables_inherited_conformance.swift b/test/IRGen/sil_witness_tables_inherited_conformance.swift index 2b535573f1247..e437ab6946bd4 100644 --- a/test/IRGen/sil_witness_tables_inherited_conformance.swift +++ b/test/IRGen/sil_witness_tables_inherited_conformance.swift @@ -23,7 +23,7 @@ class Anesthesiologist : Veterinarian { } func breed(_ t: T) { } -// CHECK-LABEL: define hidden swiftcc void @"$s40sil_witness_tables_inherited_conformance4feed{{[_0-9a-zA-Z]*}}F"(%T40sil_witness_tables_inherited_conformance3CatC*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @"$s40sil_witness_tables_inherited_conformance4feed{{[_0-9a-zA-Z]*}}F"(%T40sil_witness_tables_inherited_conformance3CatC* %0, %swift.type* %T) func feed(_ t: T) { // CHECK: call swiftcc void @"$s40sil_witness_tables_inherited_conformance5breed{{[_0-9a-zA-Z]*}}F"{{.*}} @"$s40sil_witness_tables_inherited_conformance3CatCAA5PandaAAWP" breed(t) @@ -33,7 +33,7 @@ func obtain(_ t: T.Type) { t.init() } -// CHECK-LABEL: define hidden swiftcc void @"$s40sil_witness_tables_inherited_conformance6wangle{{[_0-9a-zA-Z]*}}F"(%swift.type*, %swift.type* %T) +// CHECK-LABEL: define hidden swiftcc void @"$s40sil_witness_tables_inherited_conformance6wangle{{[_0-9a-zA-Z]*}}F"(%swift.type* %0, %swift.type* %T) func wangle(_ t: T.Type) { // CHECK: call swiftcc void @"$s40sil_witness_tables_inherited_conformance6obtain{{[_0-9a-zA-Z]*}}F"{{.*}} @"$s40sil_witness_tables_inherited_conformance3CatCAA5PandaAAWP" obtain(t) diff --git a/test/IRGen/static_initializer.sil b/test/IRGen/static_initializer.sil index 9f4ba9b48c18a..a7a1863049a32 100644 --- a/test/IRGen/static_initializer.sil +++ b/test/IRGen/static_initializer.sil @@ -181,7 +181,7 @@ bb0: return %1 : $TestArray } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T18static_initializer16TestArrayStorageC* @phi_nodes(i1, %T18static_initializer16TestArrayStorageC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T18static_initializer16TestArrayStorageC* @phi_nodes(i1 %0, %T18static_initializer16TestArrayStorageC* %1) // CHECK: [[T0:%.*]] = call %swift.refcounted* @swift_initStaticObject // CHECK: [[T1:%.*]] = bitcast %swift.refcounted* [[T0]] to %T18static_initializer16TestArrayStorageC* // CHECK: br diff --git a/test/IRGen/struct_resilience.swift b/test/IRGen/struct_resilience.swift index b4d4df28850c5..c47b446e131f0 100644 --- a/test/IRGen/struct_resilience.swift +++ b/test/IRGen/struct_resilience.swift @@ -15,7 +15,7 @@ import resilient_enum // Resilient structs from outside our resilience domain are manipulated via // value witnesses -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience30functionWithResilientTypesSize_1f010resilient_A00G0VAFn_A2FnXEtF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, i8*, %swift.opaque*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience30functionWithResilientTypesSize_1f010resilient_A00G0VAFn_A2FnXEtF"(%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, i8* %2, %swift.opaque* %3) public func functionWithResilientTypesSize(_ s: __owned Size, f: (__owned Size) -> Size) -> Size { // CHECK: entry: @@ -60,7 +60,7 @@ public func functionWithResilientTypesSize(_ s: __owned Size, f: (__owned Size) // Make sure we use a type metadata accessor function, and load indirect // field offsets from it. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience35functionWithResilientTypesRectangleyy010resilient_A00G0VF"(%T16resilient_struct9RectangleV* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience35functionWithResilientTypesRectangleyy010resilient_A00G0VF"(%T16resilient_struct9RectangleV* noalias nocapture %0) public func functionWithResilientTypesRectangle(_ r: Rectangle) { // CHECK: entry: // CHECK-NEXT: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct9RectangleVMa"([[INT]] 0) @@ -89,7 +89,7 @@ public struct MySize { public let h: Int } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience32functionWithMyResilientTypesSize_1fAA0eH0VAEn_A2EnXEtF"(%T17struct_resilience6MySizeV* noalias nocapture sret, %T17struct_resilience6MySizeV* noalias nocapture dereferenceable({{8|(16)}}), i8*, %swift.opaque*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience32functionWithMyResilientTypesSize_1fAA0eH0VAEn_A2EnXEtF"(%T17struct_resilience6MySizeV* noalias nocapture sret %0, %T17struct_resilience6MySizeV* noalias nocapture dereferenceable({{8|(16)}}) %1, i8* %2, %swift.opaque* %3) public func functionWithMyResilientTypesSize(_ s: __owned MySize, f: (__owned MySize) -> MySize) -> MySize { // There's an alloca for debug info? @@ -180,14 +180,14 @@ public struct ResilientStructWithMethod { // Corner case -- type is address-only in SIL, but empty in IRGen -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience29partialApplyOfResilientMethod1ryAA0f10StructWithG0V_tF"(%T17struct_resilience25ResilientStructWithMethodV* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience29partialApplyOfResilientMethod1ryAA0f10StructWithG0V_tF"(%T17struct_resilience25ResilientStructWithMethodV* noalias nocapture %0) public func partialApplyOfResilientMethod(r: ResilientStructWithMethod) { _ = r.method } // Type is address-only in SIL, and resilient in IRGen -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience29partialApplyOfResilientMethod1sy010resilient_A04SizeV_tF"(%swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s17struct_resilience29partialApplyOfResilientMethod1sy010resilient_A04SizeV_tF"(%swift.opaque* noalias nocapture %0) public func partialApplyOfResilientMethod(s: Size) { _ = s.method } @@ -198,7 +198,7 @@ public func resilientAny(s : ResilientWeakRef) { wantsAny(s) } -// CHECK-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience12resilientAny1sy0c1_A016ResilientWeakRefV_tF"(%swift.opaque* noalias nocapture) +// CHECK-LABEL: define{{.*}} swiftcc void @"$s17struct_resilience12resilientAny1sy0c1_A016ResilientWeakRefV_tF"(%swift.opaque* noalias nocapture %0) // CHECK: entry: // CHECK: [[ANY:%.*]] = alloca %Any // CHECK: [[META:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct16ResilientWeakRefVMa"([[INT]] 0) @@ -296,11 +296,11 @@ public func memoryLayoutDotOffsetOfWithResilientStruct() -> Int? { // Public metadata accessor for our resilient struct // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s17struct_resilience6MySizeVMa" -// CHECK-SAME: ([[INT]]) +// CHECK-SAME: ([[INT]] %0) // CHECK: ret %swift.metadata_response { %swift.type* bitcast ([[INT]]* getelementptr inbounds {{.*}} @"$s17struct_resilience6MySizeVMf", i32 0, i32 1) to %swift.type*), [[INT]] 0 } -// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s17struct_resilience26StructWithResilientStorageVMr"(%swift.type*, i8*, i8**) +// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s17struct_resilience26StructWithResilientStorageVMr"(%swift.type* %0, i8* %1, i8** %2) // CHECK: [[FIELDS:%.*]] = alloca [4 x i8**] // CHECK: [[TUPLE_LAYOUT:%.*]] = alloca %swift.full_type_layout, diff --git a/test/IRGen/struct_with_resilient_type.swift b/test/IRGen/struct_with_resilient_type.swift index 0136249ab55c2..0201209d01538 100644 --- a/test/IRGen/struct_with_resilient_type.swift +++ b/test/IRGen/struct_with_resilient_type.swift @@ -27,7 +27,7 @@ struct ProtAndResilStruct { func crash() { fooImp.foo(ptr: bar) } -// CHECK-LABEL: define{{.*}} @"$s26struct_with_resilient_type18ProtAndResilStructV3baryyFTc"(%T26struct_with_resilient_type18ProtAndResilStructV* noalias nocapture) +// CHECK-LABEL: define{{.*}} @"$s26struct_with_resilient_type18ProtAndResilStructV3baryyFTc"(%T26struct_with_resilient_type18ProtAndResilStructV* noalias nocapture %0) // CHECK: [[T0:%.*]] = zext i32 %flags to i64 // CHECK: %flags.alignmentMask = and i64 [[T0]], 255 // CHECK: [[XOR_ALIGN:%.*]] = xor i64 %flags.alignmentMask, -1 diff --git a/test/IRGen/subclass.swift b/test/IRGen/subclass.swift index d7bcd7a06880b..e8fe6a1a8e583 100644 --- a/test/IRGen/subclass.swift +++ b/test/IRGen/subclass.swift @@ -61,7 +61,7 @@ class G : A { // Ensure that downcasts to generic types instantiate generic metadata instead // of trying to reference global metadata. -// CHECK: define hidden swiftcc %T8subclass1GCySiG* @"$s8subclass9a_to_gint1aAA1GCySiGAA1AC_tF"(%T8subclass1AC*) {{.*}} { +// CHECK: define hidden swiftcc %T8subclass1GCySiG* @"$s8subclass9a_to_gint1aAA1GCySiGAA1AC_tF"(%T8subclass1AC* %0) {{.*}} { func a_to_gint(a: A) -> G { // CHECK: call {{.*}} @__swift_instantiateConcreteTypeFromMangledName({{.*}} @"$s8subclass1GCySiGMD") // CHECK: call i8* @swift_dynamicCastClassUnconditional diff --git a/test/IRGen/subclass_existentials.sil b/test/IRGen/subclass_existentials.sil index 246a4be511416..28295cc27dfa1 100644 --- a/test/IRGen/subclass_existentials.sil +++ b/test/IRGen/subclass_existentials.sil @@ -18,8 +18,8 @@ protocol R {} // Make sure we use native reference counting when the existential has a Swift // class bound. -// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkRefcounting(%T21subclass_existentials1CC*, i8**, %objc_object*, i8**) -// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkRefcounting(%T21subclass_existentials1CC*, i8**, %swift.refcounted*, i8**) +// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkRefcounting(%T21subclass_existentials1CC* %0, i8** %1, %objc_object* %2, i8** %3) +// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkRefcounting(%T21subclass_existentials1CC* %0, i8** %1, %swift.refcounted* %2, i8** %3) // CHECK-NEXT: entry: // CHECK-objc-NEXT: call void @swift_unknownObjectRelease(%objc_object* %2) // CHECK-native-NEXT: call void @swift_release(%swift.refcounted* %2) @@ -55,7 +55,7 @@ bb0: return %4 : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %T21subclass_existentials1CC*, i8** } @eraseToExistential(%T21subclass_existentials1DC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %T21subclass_existentials1CC*, i8** } @eraseToExistential(%T21subclass_existentials1DC* %0) // CHECK: [[INSTANCE:%.*]] = bitcast %T21subclass_existentials1DC* %0 to %T21subclass_existentials1CC* // CHECK-NEXT: [[RESULT1:%.*]] = insertvalue { %T21subclass_existentials1CC*, i8** } undef, %T21subclass_existentials1CC* [[INSTANCE]], 0 // CHECK-NEXT: [[RESULT2:%.*]] = insertvalue { %T21subclass_existentials1CC*, i8** } [[RESULT1]], i8** @"$s21subclass_existentials1DCAA1PAAWP", 1 @@ -66,7 +66,7 @@ bb0(%0 : $D): return %2 : $C & P } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %T21subclass_existentials1GC*, i8** } @eraseToExistentialWithGeneric(%T21subclass_existentials1EC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { %T21subclass_existentials1GC*, i8** } @eraseToExistentialWithGeneric(%T21subclass_existentials1EC* %0) // CHECK: [[INSTANCE:%.*]] = bitcast %T21subclass_existentials1EC* %0 to %T21subclass_existentials1GC* // CHECK-NEXT: [[RESULT1:%.*]] = insertvalue { %T21subclass_existentials1GC*, i8** } undef, %T21subclass_existentials1GC* [[INSTANCE]], 0 // CHECK-NEXT: [[RESULT2:%.*]] = insertvalue { %T21subclass_existentials1GC*, i8** } [[RESULT1]], i8** @"$s21subclass_existentials1ECyxGAA1PAAWP", 1 @@ -77,7 +77,7 @@ bb0(%0 : $E<τ_0_0>): return %2 : $G<τ_0_0> & P } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialDowncast(%T21subclass_existentials1CC*, %T21subclass_existentials1CC*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialDowncast(%T21subclass_existentials1CC* %0, %T21subclass_existentials1CC* %1, i8** %2) sil [ossa] @checkExistentialDowncast : $@convention(thin) (@owned C, @owned C & P) -> () { bb0(%0 : @owned $C, %1 : @owned $C & P): @@ -109,7 +109,7 @@ bb0(%0 : @owned $C, %1 : @owned $C & P): return %result : $() } -// CHECK-LABEL: define private { i8*, i8** } @dynamic_cast_existential_1_superclass_unconditional(i8*, %swift.type*, %swift.type* +// CHECK-LABEL: define private { i8*, i8** } @dynamic_cast_existential_1_superclass_unconditional(i8* %0, %swift.type* %1, %swift.type* // CHECK: entry: // CHECK-NEXT: [[RESULT:%.*]] = call %swift.type* @swift_dynamicCastMetatype(%swift.type* %1, %swift.type* %2) // CHECK-NEXT: [[IS_SUBCLASS:%.*]] = icmp ne %swift.type* [[RESULT]], null @@ -129,7 +129,7 @@ bb0(%0 : @owned $C, %1 : @owned $C & P): // CHECK-NEXT: call void @llvm.trap() // CHECK-NEXT: unreachable -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialSameClassDowncast(%T21subclass_existentials1CC*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialSameClassDowncast(%T21subclass_existentials1CC* %0) sil [ossa] @checkExistentialSameClassDowncast : $@convention(thin) (@owned C) -> () { bb0(%0 : @owned $C): @@ -150,7 +150,7 @@ bb0(%0 : @owned $C): return %result : $() } -// CHECK-LABEL: define private { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8*, %swift.type* +// CHECK-LABEL: define private { i8*, i8** } @dynamic_cast_existential_1_unconditional(i8* %0, %swift.type* // CHECK: entry: // CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_conformsToProtocol(%swift.type* %1, {{.*}} %2) // CHECK-NEXT: [[IS_NOT_CONFORMING:%.*]] = icmp eq i8** [[WTABLE]], null @@ -165,7 +165,7 @@ bb0(%0 : @owned $C): // CHECK-NEXT: call void @llvm.trap() // CHECK-NEXT: unreachable -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialMetatypeDowncast(%swift.type*, %swift.type*, i8**) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialMetatypeDowncast(%swift.type* %0, %swift.type* %1, i8** %2) sil @checkExistentialMetatypeDowncast : $@convention(thin) (@owned @thick C.Type, @owned @thick (C & P).Type) -> () { bb0(%0 : $@thick C.Type, %1 : $@thick (C & P).Type): @@ -186,7 +186,7 @@ bb0(%0 : $@thick C.Type, %1 : $@thick (C & P).Type): return %result : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialSameClassMetatypeDowncast(%swift.type*) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @checkExistentialSameClassMetatypeDowncast(%swift.type* %0) sil @checkExistentialSameClassMetatypeDowncast : $@convention(thin) (@owned @thick C.Type) -> () { bb0(%0 : $@thick C.Type): diff --git a/test/IRGen/super.sil b/test/IRGen/super.sil index db77f61d997f4..e5e298a365fde 100644 --- a/test/IRGen/super.sil +++ b/test/IRGen/super.sil @@ -60,7 +60,7 @@ bb0(%0 : $ChildToResilientParent): } // ChildToResilientParent is in our resilience domain - can load the superclass's metadata directly. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super22ChildToResilientParentC6methodyyF"(%T5super22ChildToResilientParentC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super22ChildToResilientParentC6methodyyF"(%T5super22ChildToResilientParentC* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s15resilient_class22ResilientOutsideParentCMa"([[INT]] 0) // CHECK: [[SUPER_METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[FN:%.*]] = call swiftcc i8* @"$s15resilient_class22ResilientOutsideParentCMu"(%swift.type* [[SUPER_METADATA]], %swift.method_descriptor* @"$s15resilient_class22ResilientOutsideParentC6methodyyFTq") @@ -79,7 +79,7 @@ bb0(%0 : $@thick ChildToResilientParent.Type): } // ChildToResilientParent is in our resilience domain - can load the superclass's metadata directly. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super22ChildToResilientParentC11classMethodyyFZ"(%swift.type* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super22ChildToResilientParentC11classMethodyyFZ"(%swift.type* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s15resilient_class22ResilientOutsideParentCMa"([[INT]] 0) // CHECK: [[SUPER_METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[FN:%.*]] = call swiftcc i8* @"$s15resilient_class22ResilientOutsideParentCMu"(%swift.type* [[SUPER_METADATA]], %swift.method_descriptor* @"$s15resilient_class22ResilientOutsideParentC0B6MethodyyFZTq") @@ -106,7 +106,7 @@ bb0(%0 : $ChildToFixedParent): return %7 : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super18ChildToFixedParentC6methodyyF"(%T5super18ChildToFixedParentC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super18ChildToFixedParentC6methodyyF"(%T5super18ChildToFixedParentC* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s18fixed_layout_class13OutsideParentCMa"([[INT]] 0) // CHECK: [[SUPER_METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[OPAQUE_SUPER_METADATA:%.*]] = bitcast %swift.type* [[SUPER_METADATA]] to void (%T18fixed_layout_class13OutsideParentC*)** @@ -127,7 +127,7 @@ bb0(%0 : $@thick ChildToFixedParent.Type): } // ChildToFixedParent is in our resilience domain - load super metadata directly. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super18ChildToFixedParentC11classMethodyyFZ"(%swift.type* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s5super18ChildToFixedParentC11classMethodyyFZ"(%swift.type* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s18fixed_layout_class13OutsideParentCMa"([[INT]] 0) // CHECK: [[SUPER_METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[OPAQUE_SUPER_METADATA:%.*]] = bitcast %swift.type* [[SUPER_METADATA]] to void (%swift.type*)** @@ -150,7 +150,7 @@ bb0(%0 : $ResilientOutsideChild): } // Extending a resilient class - load super metadata indirectly. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15resilient_class21ResilientOutsideChildC5superE15callSuperMethodyyF"(%T15resilient_class21ResilientOutsideChildC* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15resilient_class21ResilientOutsideChildC5superE15callSuperMethodyyF"(%T15resilient_class21ResilientOutsideChildC* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s15resilient_class21ResilientOutsideChildCMa"([[INT]] 0) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[OPAQUE_METADATA:%.*]] = bitcast %swift.type* [[METADATA]] to %swift.type** @@ -173,7 +173,7 @@ bb0(%0 : $@thick ResilientOutsideChild.Type): } // Extending a resilient class - load super metadata indirectly. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15resilient_class21ResilientOutsideChildC5superE20callSuperClassMethodyyFZ"(%swift.type* swiftself) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15resilient_class21ResilientOutsideChildC5superE20callSuperClassMethodyyFZ"(%swift.type* swiftself %0) // CHECK: [[TMP:%.*]] = call swiftcc %swift.metadata_response @"$s15resilient_class21ResilientOutsideChildCMa"([[INT]] 0) // CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[TMP]], 0 // CHECK: [[OPAQUE_METADATA:%.*]] = bitcast %swift.type* [[METADATA]] to %swift.type** diff --git a/test/IRGen/unconditional_checked_cast.sil b/test/IRGen/unconditional_checked_cast.sil index eb0426f065179..b2bfb88065c80 100644 --- a/test/IRGen/unconditional_checked_cast.sil +++ b/test/IRGen/unconditional_checked_cast.sil @@ -10,7 +10,7 @@ sil_vtable C {} class D : C {} sil_vtable D {} -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @downcast_test(%T26unconditional_checked_cast1DC** noalias nocapture sret, %T26unconditional_checked_cast1CC** nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @downcast_test(%T26unconditional_checked_cast1DC** noalias nocapture sret %0, %T26unconditional_checked_cast1CC** nocapture dereferenceable({{.*}}) %1) {{.*}} { // CHECK: entry: // CHECK-NEXT: [[INPUTPTR:%[0-9]+]] = load %T26unconditional_checked_cast1CC*, %T26unconditional_checked_cast1CC** [[INPUTPTRPTR:%[0-9]+]], align 8 // CHECK-NEXT: [[I8INPUTPTR:%[0-9]+]] = bitcast %T26unconditional_checked_cast1CC* [[INPUTPTR]] to i8* diff --git a/test/IRGen/unexploded-calls.swift b/test/IRGen/unexploded-calls.swift index 8c21e387ced81..f3fb66533c63e 100644 --- a/test/IRGen/unexploded-calls.swift +++ b/test/IRGen/unexploded-calls.swift @@ -17,7 +17,7 @@ public func g(_ s : S) { return f(s) } -// CHECK: define {{.*}}swiftcc void @"$ss1gyySo1SVF"(float, float) {{.*}}{ +// CHECK: define {{.*}}swiftcc void @"$ss1gyySo1SVF"(float %0, float %1) {{.*}}{ // CHECK: entry: // CHECK: alloca // CHECK: [[ALLOCA:%[-._0-9a-zA-Z]+]] = alloca %TSo1SV, align 4 diff --git a/test/IRGen/unowned.sil b/test/IRGen/unowned.sil index b5310fe71bf56..4ea7ec0e7802d 100644 --- a/test/IRGen/unowned.sil +++ b/test/IRGen/unowned.sil @@ -30,7 +30,7 @@ bb0(%0 : $@sil_unowned C): %3 = tuple () return %3 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]*) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]* %0) {{.*}} { // CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0) // CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* %0) // CHECK-NEXT: ret void @@ -42,7 +42,7 @@ bb0(%0 : $@sil_unowned P): %3 = tuple () return %3 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_proto(%swift.refcounted*, i8**) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_proto(%swift.refcounted* %0, i8** %1) {{.*}} { // CHECK: call %swift.refcounted* @swift_unownedRetain(%swift.refcounted* returned %0) // CHECK: call void @swift_unownedRelease(%swift.refcounted* %0) // CHECK-NEXT: ret void diff --git a/test/IRGen/unowned_objc.sil b/test/IRGen/unowned_objc.sil index ecbb3bff3ebe3..4a95c1ae5164d 100644 --- a/test/IRGen/unowned_objc.sil +++ b/test/IRGen/unowned_objc.sil @@ -35,12 +35,12 @@ bb0(%0 : $@sil_unowned C): %3 = tuple () return %3 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]*) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]* %0) {{.*}} { // CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0) // CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* %0) // CHECK-NEXT: ret void -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_unknown_unowned_copies([[UNKNOWN]]*, i8**, [[UNKNOWN]]*, i8**) +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_unknown_unowned_copies([[UNKNOWN]]* %0, i8** %1, [[UNKNOWN]]* %2, i8** %3) sil @test_unknown_unowned_copies : $@convention(thin) (@owned P, @owned P) -> () { bb0(%p : $P, %q : $P): diff --git a/test/IRGen/upcast.sil b/test/IRGen/upcast.sil index 947a3ced5eeb5..365ea261e1985 100644 --- a/test/IRGen/upcast.sil +++ b/test/IRGen/upcast.sil @@ -2,7 +2,7 @@ // Make sure that we are able to lower upcast addresses. -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @upcast_test(%T6upcast1DC** nocapture dereferenceable({{.*}})) {{.*}} { +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @upcast_test(%T6upcast1DC** nocapture dereferenceable({{.*}}) %0) {{.*}} { // CHECK: entry: // CHECK-NEXT: bitcast %T6upcast1DC** {{%[0-0]+}} to %T6upcast1CC** // CHECK-NEXT: ret void diff --git a/test/IRGen/value_buffers.sil b/test/IRGen/value_buffers.sil index c23665ae02d7b..22d268c5d7d28 100644 --- a/test/IRGen/value_buffers.sil +++ b/test/IRGen/value_buffers.sil @@ -18,7 +18,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer, %v : $Int): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @alloc_small([24 x i8]* nocapture dereferenceable({{.*}}), i64) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @alloc_small([24 x i8]* nocapture dereferenceable({{.*}}) %0, i64 %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[T0:%.*]] = bitcast [24 x i8]* %0 to %TSi* // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds %TSi, %TSi* [[T0]], i32 0, i32 0 @@ -32,7 +32,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer, %v : $Int): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @project_small([24 x i8]* nocapture dereferenceable({{.*}}), i64) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @project_small([24 x i8]* nocapture dereferenceable({{.*}}) %0, i64 %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[T0:%.*]] = bitcast [24 x i8]* %0 to %TSi* // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds %TSi, %TSi* [[T0]], i32 0, i32 0 @@ -45,7 +45,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_small([24 x i8]* nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_small([24 x i8]* nocapture dereferenceable({{.*}}) %0) // CHECK-NEXT: entry: // CHECK-NEXT: ret void @@ -56,7 +56,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer, %v : $BigStruct): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @alloc_big([24 x i8]* nocapture dereferenceable({{.*}}), %T13value_buffers9BigStructV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @alloc_big([24 x i8]* nocapture dereferenceable({{.*}}) %0, %T13value_buffers9BigStructV* noalias nocapture dereferenceable({{.*}}) %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[T0:%.*]] = call noalias i8* @swift_slowAlloc(i64 48, i64 7) // CHECK-NEXT: [[T1:%.*]] = bitcast [24 x i8]* %0 to i8** @@ -74,7 +74,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer, %v : $BigStruct): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @project_big([24 x i8]* nocapture dereferenceable({{.*}}), %T13value_buffers9BigStructV* noalias nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @project_big([24 x i8]* nocapture dereferenceable({{.*}}) %0, %T13value_buffers9BigStructV* noalias nocapture dereferenceable({{.*}}) %1) // CHECK-NEXT: entry: // CHECK-NEXT: [[T0:%.*]] = bitcast [24 x i8]* %0 to %T13value_buffers9BigStructV** // CHECK-NEXT: [[ADDR:%.*]] = load %T13value_buffers9BigStructV*, %T13value_buffers9BigStructV** [[T0]], align 8 @@ -89,7 +89,7 @@ entry(%b : $*Builtin.UnsafeValueBuffer): %r = tuple () return %r : $() } -// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_big([24 x i8]* nocapture dereferenceable({{.*}})) +// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dealloc_big([24 x i8]* nocapture dereferenceable({{.*}}) %0) // CHECK-NEXT: entry: // CHECK-NEXT: [[T0:%.*]] = bitcast [24 x i8]* %0 to i8** // CHECK-NEXT: [[ADDR:%.*]] = load i8*, i8** [[T0]], align 8 diff --git a/test/IRGen/weak.sil b/test/IRGen/weak.sil index f2c3e75d84a69..5bd1961e3b99a 100644 --- a/test/IRGen/weak.sil +++ b/test/IRGen/weak.sil @@ -41,7 +41,7 @@ bb0(%0 : $*A, %1 : $Optional): %4 = tuple () return %4 : $() } -// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_load_store([[A]]* nocapture dereferenceable({{.*}}), i64) {{.*}} { +// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_weak_load_store([[A]]* nocapture dereferenceable({{.*}}) %0, i64 %1) {{.*}} { // CHECK: [[X:%.*]] = getelementptr inbounds [[A]], [[A]]* %0, i32 0, i32 0 // CHECK-NEXT: [[T0:%.*]] = call [[C]]* bitcast ([[REF]]* ([[WEAK]]*)* @swift_weakLoadStrong to [[C]]* ([[WEAK]]*)*)([[WEAK]]* [[X]]) // CHECK-NEXT: %3 = ptrtoint %T4weak1CC* %2 to i64 @@ -64,7 +64,7 @@ bb0(%0 : $*B, %1 : $Optional