diff options
Diffstat (limited to 'deprecated')
113 files changed, 71831 insertions, 0 deletions
diff --git a/deprecated/automation/PRESUBMIT.py b/deprecated/automation/PRESUBMIT.py new file mode 100644 index 00000000..56a43e6c --- /dev/null +++ b/deprecated/automation/PRESUBMIT.py @@ -0,0 +1,14 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# +# Presubmit script for cc'ing c-compiler-chrome on automation related CL's. +# +# PRESUBMIT METADATA: +# [ +# MailTo( +# p4_filespecs = [ +# "//depot2/gcctools/chromeos/v14/automation/...", +# ], +# addresses = ["c-compiler-chrome"], +# owners = ["asharif", "llozano", "bjanakiraman", "yunlian"] +# ), +# ] diff --git a/deprecated/automation/__init__.py b/deprecated/automation/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/all_tests.py b/deprecated/automation/all_tests.py new file mode 100644 index 00000000..e7b70884 --- /dev/null +++ b/deprecated/automation/all_tests.py @@ -0,0 +1,16 @@ +import glob +import sys +import unittest + +sys.path.insert(0, 'server') +sys.path.insert(0, 'clients') +sys.path.insert(0, 'common') + +test_file_strings = glob.glob('*/*_test.py') +module_strings = [str[0:len(str) - 3] for str in test_file_strings] +for i in range(len(module_strings)): + module_strings[i] = module_strings[i].split('/')[-1] +suites = [unittest.defaultTestLoader.loadTestsFromName(str) + for str in module_strings] +testSuite = unittest.TestSuite(suites) +text_runner = unittest.TextTestRunner().run(testSuite) diff --git a/deprecated/automation/clients/__init__.py b/deprecated/automation/clients/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/clients/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/clients/android.py b/deprecated/automation/clients/android.py new file mode 100755 index 00000000..06e76d29 --- /dev/null +++ b/deprecated/automation/clients/android.py @@ -0,0 +1,87 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +"""Client for Android nightly jobs. + +Does the following jobs: + 1. Checkout android toolchain sources + 2. Build Android toolchain + 3. Build Android tree + 4. Checkout/build/run Android benchmarks (TODO) + 5. Generate size/performance dashboard ? (TODO) +""" + +__author__ = 'jingyu@google.com (Jing Yu)' + +import optparse +import pickle +import sys +import xmlrpclib + +from automation.clients.helper import android +from automation.common import job_group +from automation.common import logger + + +class AndroidToolchainNightlyClient(object): + VALID_GCC_VERSIONS = ['4.4.3', '4.6', 'google_main', 'fsf_trunk'] + + def __init__(self, gcc_version, is_release): + assert gcc_version in self.VALID_GCC_VERSIONS + self.gcc_version = gcc_version + if is_release: + self.build_type = 'RELEASE' + else: + self.build_type = 'DEVELOPMENT' + + def Run(self): + server = xmlrpclib.Server('http://localhost:8000') + server.ExecuteJobGroup(pickle.dumps(self.CreateJobGroup())) + + def CreateJobGroup(self): + factory = android.JobsFactory(self.gcc_version, self.build_type) + + p4_androidtc_job, checkout_dir_dep = factory.CheckoutAndroidToolchain() + + tc_build_job, tc_prefix_dep = factory.BuildAndroidToolchain( + checkout_dir_dep) + + tree_build_job = factory.BuildAndroidImage(tc_prefix_dep) + + benchmark_job = factory.Benchmark(tc_prefix_dep) + + all_jobs = [p4_androidtc_job, tc_build_job, tree_build_job, benchmark_job] + + return job_group.JobGroup('androidtoolchain_nightly', all_jobs, True, False) + + +@logger.HandleUncaughtExceptions +def Main(argv): + valid_gcc_versions_string = ', '.join( + AndroidToolchainNightlyClient.VALID_GCC_VERSIONS) + + parser = optparse.OptionParser() + parser.add_option('--with-gcc-version', + dest='gcc_version', + default='4.6', + action='store', + choices=AndroidToolchainNightlyClient.VALID_GCC_VERSIONS, + help='gcc version: %s.' % valid_gcc_versions_string) + parser.add_option('-r', + '--release', + dest='is_release', + default=False, + action='store_true', + help='Build a release toolchain?') + options, _ = parser.parse_args(argv) + + option_list = [opt.dest for opt in parser.option_list if opt.dest] + + kwargs = dict((option, getattr(options, option)) for option in option_list) + + client = AndroidToolchainNightlyClient(**kwargs) + client.Run() + + +if __name__ == '__main__': + Main(sys.argv) diff --git a/deprecated/automation/clients/chromeos.py b/deprecated/automation/clients/chromeos.py new file mode 100755 index 00000000..572320fd --- /dev/null +++ b/deprecated/automation/clients/chromeos.py @@ -0,0 +1,104 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +"""chromeos.py: Build & Test ChromeOS using custom compilers.""" + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import logging +import optparse +import os +import pickle +import sys +import xmlrpclib + +from automation.clients.helper import jobs +from automation.clients.helper import perforce +from automation.common import command as cmd +from automation.common import job_group +from automation.common import logger + + +class ChromeOSNightlyClient(object): + DEPOT2_DIR = '//depot2/' + P4_CHECKOUT_DIR = 'perforce2/' + P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, 'gcctools/chromeos/v14') + + def __init__(self, board, remote, gcc_githash, p4_snapshot=''): + self._board = board + self._remote = remote + self._gcc_githash = gcc_githash + self._p4_snapshot = p4_snapshot + + def Run(self): + server = xmlrpclib.Server('http://localhost:8000') + server.ExecuteJobGroup(pickle.dumps(self.CreateJobGroup())) + + def CheckoutV14Dir(self): + p4view = perforce.View(self.DEPOT2_DIR, [ + perforce.PathMapping('gcctools/chromeos/v14/...') + ]) + return self.GetP4Snapshot(p4view) + + def GetP4Snapshot(self, p4view): + p4client = perforce.CommandsFactory(self.P4_CHECKOUT_DIR, p4view) + + if self._p4_snapshot: + return p4client.CheckoutFromSnapshot(self._p4_snapshot) + else: + return p4client.SetupAndDo(p4client.Sync(), p4client.Remove()) + + def CreateJobGroup(self): + chain = cmd.Chain( + self.CheckoutV14Dir(), + cmd.Shell('python', + os.path.join(self.P4_VERSION_DIR, 'test_toolchains.py'), + '--force-mismatch', + '--clean', + '--public', # crbug.com/145822 + '--board=%s' % self._board, + '--remote=%s' % self._remote, + '--githashes=%s' % self._gcc_githash)) + label = 'testlabel' + job = jobs.CreateLinuxJob(label, chain, timeout=24 * 60 * 60) + + return job_group.JobGroup(label, [job], True, False) + + +@logger.HandleUncaughtExceptions +def Main(argv): + parser = optparse.OptionParser() + parser.add_option('-b', + '--board', + dest='board', + help='Run performance tests on these boards') + parser.add_option('-r', + '--remote', + dest='remote', + help='Run performance tests on these remotes') + parser.add_option('-g', + '--gcc_githash', + dest='gcc_githash', + help='Use this gcc_githash.') + parser.add_option('-p', + '--p4_snapshot', + dest='p4_snapshot', + default='', + help='Use this p4_snapshot.') + options, _ = parser.parse_args(argv) + + if not all([options.board, options.remote, options.gcc_githash]): + logging.error('Specify a board, remote and gcc_githash') + return 1 + + client = ChromeOSNightlyClient(options.board, + options.remote, + options.gcc_githash, + p4_snapshot=options.p4_snapshot) + client.Run() + return 0 + + +if __name__ == '__main__': + logger.SetUpRootLogger(level=logging.DEBUG, display_flags={'name': False}) + sys.exit(Main(sys.argv)) diff --git a/deprecated/automation/clients/crosstool.py b/deprecated/automation/clients/crosstool.py new file mode 100755 index 00000000..9ba83807 --- /dev/null +++ b/deprecated/automation/clients/crosstool.py @@ -0,0 +1,102 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import logging +import optparse +import pickle +import sys +import xmlrpclib + +from automation.clients.helper import crosstool +from automation.common import job_group +from automation.common import logger + + +class CrosstoolNightlyClient(object): + VALID_TARGETS = ['gcc-4.6.x-ubuntu_lucid-arm', + 'gcc-4.6.x-ubuntu_lucid-x86_64', + 'gcc-4.6.x-grtev2-armv7a-vfpv3.d16-hard', + 'gcc-4.6.x-glibc-2.11.1-grte', + 'gcc-4.6.x-glibc-2.11.1-powerpc'] + VALID_BOARDS = ['qemu', 'pandaboard', 'unix'] + + def __init__(self, target, boards): + assert target in self.VALID_TARGETS + assert all(board in self.VALID_BOARDS for board in boards) + + self._target = target + self._boards = boards + + def Run(self): + server = xmlrpclib.Server('http://localhost:8000') + server.ExecuteJobGroup(pickle.dumps(self.CreateJobGroup())) + + def CreateJobGroup(self): + factory = crosstool.JobsFactory() + + checkout_crosstool_job, checkout_dir, manifests_dir = \ + factory.CheckoutCrosstool(self._target) + + all_jobs = [checkout_crosstool_job] + + # Build crosstool target + build_release_job, build_tree_dir = factory.BuildRelease(checkout_dir, + self._target) + all_jobs.append(build_release_job) + + testruns = [] + + # Perform crosstool tests + for board in self._boards: + for component in ('gcc', 'binutils'): + test_job, testrun_dir = factory.RunTests(checkout_dir, build_tree_dir, + self._target, board, component) + all_jobs.append(test_job) + testruns.append(testrun_dir) + + if testruns: + all_jobs.append(factory.GenerateReport(testruns, manifests_dir, + self._target, self._boards)) + + return job_group.JobGroup('Crosstool Nightly Build (%s)' % self._target, + all_jobs, True, False) + + +@logger.HandleUncaughtExceptions +def Main(argv): + valid_boards_string = ', '.join(CrosstoolNightlyClient.VALID_BOARDS) + + parser = optparse.OptionParser() + parser.add_option( + '-b', + '--board', + dest='boards', + action='append', + choices=CrosstoolNightlyClient.VALID_BOARDS, + default=[], + help=('Run DejaGNU tests on selected boards: %s.' % valid_boards_string)) + options, args = parser.parse_args(argv) + + if len(args) == 2: + target = args[1] + else: + logging.error('Exactly one target required as a command line argument!') + logging.info('List of valid targets:') + for pair in enumerate(CrosstoolNightlyClient.VALID_TARGETS, start=1): + logging.info('%d) %s', pair) + sys.exit(1) + + option_list = [opt.dest for opt in parser.option_list if opt.dest] + + kwargs = dict((option, getattr(options, option)) for option in option_list) + + client = CrosstoolNightlyClient(target, **kwargs) + client.Run() + + +if __name__ == '__main__': + logger.SetUpRootLogger(level=logging.DEBUG, display_flags={'name': False}) + Main(sys.argv) diff --git a/deprecated/automation/clients/dejagnu_compiler.py b/deprecated/automation/clients/dejagnu_compiler.py new file mode 100755 index 00000000..7448b87e --- /dev/null +++ b/deprecated/automation/clients/dejagnu_compiler.py @@ -0,0 +1,98 @@ +#!/usr/bin/python2 +# +# Copyright 2012 Google Inc. All Rights Reserved. +"""dejagnu_compiler.py: Run dejagnu test.""" + +__author__ = 'shenhan@google.com (Han Shen)' + +import logging +import optparse +import os +import pickle +import sys +import xmlrpclib + +from automation.clients.helper import jobs +from automation.clients.helper import perforce +from automation.common import command as cmd +from automation.common import job_group +from automation.common import logger + + +class DejagnuCompilerNightlyClient: + DEPOT2_DIR = '//depot2/' + P4_CHECKOUT_DIR = 'perforce2/' + P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, 'gcctools/chromeos/v14') + + def __init__(self, board, remote, p4_snapshot, cleanup): + self._board = board + self._remote = remote + self._p4_snapshot = p4_snapshot + self._cleanup = cleanup + + def Run(self): + server = xmlrpclib.Server('http://localhost:8000') + server.ExecuteJobGroup(pickle.dumps(self.CreateJobGroup())) + + def CheckoutV14Dir(self): + p4view = perforce.View(self.DEPOT2_DIR, [ + perforce.PathMapping('gcctools/chromeos/v14/...') + ]) + return self.GetP4Snapshot(p4view) + + def GetP4Snapshot(self, p4view): + p4client = perforce.CommandsFactory(self.P4_CHECKOUT_DIR, p4view) + + if self._p4_snapshot: + return p4client.CheckoutFromSnapshot(self._p4_snapshot) + else: + return p4client.SetupAndDo(p4client.Sync(), p4client.Remove()) + + def CreateJobGroup(self): + chain = cmd.Chain(self.CheckoutV14Dir(), cmd.Shell( + 'python', os.path.join(self.P4_VERSION_DIR, 'test_gcc_dejagnu.py'), + '--board=%s' % self._board, '--remote=%s' % self._remote, + '--cleanup=%s' % self._cleanup)) + label = 'dejagnu' + job = jobs.CreateLinuxJob(label, chain, timeout=8 * 60 * 60) + return job_group.JobGroup(label, + [job], + cleanup_on_failure=True, + cleanup_on_completion=True) + + +@logger.HandleUncaughtExceptions +def Main(argv): + parser = optparse.OptionParser() + parser.add_option('-b', + '--board', + dest='board', + help='Run performance tests on these boards') + parser.add_option('-r', + '--remote', + dest='remote', + help='Run performance tests on these remotes') + parser.add_option('-p', + '--p4_snapshot', + dest='p4_snapshot', + help=('For development only. ' + 'Use snapshot instead of checking out.')) + parser.add_option('--cleanup', + dest='cleanup', + default='mount', + help=('Cleanup test directory, values could be one of ' + '"mount", "chroot" or "chromeos"')) + options, _ = parser.parse_args(argv) + + if not all([options.board, options.remote]): + logging.error('Specify a board and remote.') + return 1 + + client = DejagnuCompilerNightlyClient(options.board, options.remote, + options.p4_snapshot, options.cleanup) + client.Run() + return 0 + + +if __name__ == '__main__': + sys.exit(Main(sys.argv)) diff --git a/deprecated/automation/clients/helper/__init__.py b/deprecated/automation/clients/helper/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/clients/helper/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/clients/helper/android.py b/deprecated/automation/clients/helper/android.py new file mode 100644 index 00000000..7ff2ac1c --- /dev/null +++ b/deprecated/automation/clients/helper/android.py @@ -0,0 +1,319 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +"""Helper modules for Android toolchain test infrastructure. + +Provides following Android toolchain test jobs and commands. +. Checkout Android toolchain source code +. Build Android toolchain +. Checkout and build Android tree +. Checkout/build/run Android benchmarks, generate size dashboard +. Transform size dashboard to report, send perflab jobid to + perflab dashboard server.(TODO) +""" + +__author__ = 'jingyu@google.com (Jing Yu)' + +import os.path + +from automation.clients.helper import jobs +from automation.clients.helper import perforce +from automation.common import command as cmd +from automation.common import job + + +class JobsFactory(object): + + def __init__(self, gcc_version='4.4.3', build_type='DEVELOPMENT'): + assert gcc_version in ['4.4.3', '4.6', 'google_main', 'fsf_trunk'] + assert build_type in ['DEVELOPMENT', 'RELEASE'] + + self.gcc_version = gcc_version + self.commands = CommandsFactory(gcc_version, build_type) + self.tc_tag = 'gcc-%s-%s' % (gcc_version, build_type) + + def CheckoutAndroidToolchain(self): + """Check out Android toolchain sources by release and gcc version.""" + command = self.commands.CheckoutAndroidToolchain() + new_job = jobs.CreateLinuxJob('AndroidCheckoutToolchain(%s)' % self.tc_tag, + command) + checkout_dir_dep = job.FolderDependency(new_job, self.commands.CHECKOUT_DIR) + return new_job, checkout_dir_dep + + def BuildAndroidToolchain(self, checkout_dir_dep): + """Build Android Toolchain.""" + command = self.commands.BuildAndroidToolchain() + new_job = jobs.CreateLinuxJob('AndroidBuildToolchain(%s)' % self.tc_tag, + command) + new_job.DependsOnFolder(checkout_dir_dep) + tc_prefix_dep = job.FolderDependency(new_job, + self.commands.toolchain_prefix_dir) + return new_job, tc_prefix_dep + + def BuildAndroidImage(self, + tc_prefix_dep, + product='stingray', + branch='ics-release'): + assert product in ['stingray', 'passion', 'trygon', 'soju'] + assert branch in ['honeycomb-release', 'ics-release'] + command = self.commands.BuildAndroidImage(product, branch) + new_job = jobs.CreateLinuxJob('AndroidGetBuildTree(%s)' % self.tc_tag, + command) + new_job.DependsOnFolder(tc_prefix_dep) + return new_job + + def Benchmark(self, tc_prefix_dep, arch='soju'): + assert arch in ['soju', 'stingray'] + script_cmd = self.commands.CheckoutScripts() + experiment_tag = 'android/nightly/%s/%s/$JOB_ID' % (self.tc_tag, arch) + build_run_benchmark_cmd = self.commands.BuildRunBenchmark(arch, + experiment_tag) + command = cmd.Chain(script_cmd, build_run_benchmark_cmd) + new_job = jobs.CreateLinuxJob('AndroidBenchmarking(%s)' % self.tc_tag, + command) + new_job.DependsOnFolder(tc_prefix_dep) + return new_job + + +class CommandsFactory(object): + CHECKOUT_DIR = 'androidtc-checkout-dir' + TOOLCHAIN_SRC_DIR = os.path.join(CHECKOUT_DIR, 'src') + TOOLCHAIN_BUILD_DIR = 'obj' + ANDROID_TREES_DIR = 'android_trees' + TOOLS_DIR = 'android-tools' + BENCHMARK_OUT_DIR = 'results' + + def __init__(self, gcc_version, build_type): + assert gcc_version in ['4.4.3', '4.6', 'google_main', 'fsf_trunk'] + assert build_type in ['DEVELOPMENT', 'RELEASE'] + + self.build_type = build_type + self.gcc_version = gcc_version + self.binutils_version = '2.21' + self.gold_version = '2.21' + self.toolchain_prefix_dir = 'install-gcc-%s-%s' % (gcc_version, build_type) + self.p4client = self._CreatePerforceClient() + self.scripts = ScriptsFactory(self.gcc_version, self.binutils_version, + self.gold_version) + + def _CreatePerforceClient(self): + p4_dev_path = 'gcctools/google_vendor_src_branch' + mobile_rel_branch = ('branches/' + 'mobile_toolchain_v15_release_branch/gcctools/' + 'google_vendor_src_branch') + gcc_443_rel_branch = ('branches/' + 'android_compiler_v14_release_branch/gcctools/' + 'google_vendor_src_branch') + + # Common views for tools + p4view = perforce.View('depot2', perforce.PathMapping.ListFromPathTuples([( + 'gcctools/android/build/...', 'src/build/...'), ( + 'gcctools/android/Tarballs/...', 'src/tarballs/...')])) + for mapping in perforce.PathMapping.ListFromPathDict( + {'gcctools/android': ['tools/scripts/...', 'master/...']}): + p4view.add(mapping) + + # Add views for gdb + p4view.add(perforce.PathMapping(p4_dev_path, 'src', + 'gdb/gdb-7.1.x-android/...')) + + # Add view for binutils for ld and gold + if self.build_type is 'RELEASE': + binutils_branch = mobile_rel_branch + else: + binutils_branch = p4_dev_path + p4view.add(perforce.PathMapping(binutils_branch, 'src', ( + 'binutils/binutils-%s/...' % self.binutils_version))) + if self.binutils_version != self.gold_version: + p4view.add(perforce.PathMapping(binutils_branch, 'src', ( + 'binutils/binutils-%s/...' % self.gold_version))) + + # Add view for gcc if gcc_version is '4.4.3'. + if self.gcc_version == '4.4.3': + gcc443_path = 'gcc/gcc-4.4.3/...' + if self.build_type is 'RELEASE': + p4view.add(perforce.PathMapping(gcc_443_rel_branch, 'src', gcc443_path)) + else: + p4view.add(perforce.PathMapping(p4_dev_path, 'src', gcc443_path)) + + return perforce.CommandsFactory(self.CHECKOUT_DIR, p4view) + + def _CheckoutGCCFromSVN(self): + """Check out gcc from fsf svn. + + Return the command that check out gcc from svn + to gcc_required_dir (=TOOLCHAIN_SRC_DIR/src/gcc/gcc-xxx). + + TODO: + Create a svn class that does these jobs. + Parallelize p4 checkout and svn checkout. + """ + if self.gcc_version == '4.4.3': + return '' + assert self.gcc_version in ['4.6', 'google_main', 'fsf_trunk'] + + gcc_branches_dir = {'4.6': 'branches/google/gcc-4_6', + 'google_main': 'branches/google/main', + 'fsf_trunk': 'trunk'} + + # Find GCC revision number, output it to TOOLCHAIN_SRC_DIR/CLNUM_GCC + svn_get_revision = cmd.Pipe( + cmd.Shell('svn', 'info'), + cmd.Shell('grep', '"Revision:"'), + cmd.Shell('sed', '-E', '"s,Revision: ([0-9]+).*,\\1,"'), + output='../../../CLNUM_GCC') + + svn_co_command = 'svn co svn://gcc.gnu.org/svn/gcc/%s .' % ( + gcc_branches_dir[self.gcc_version]) + + gcc_required_dir = os.path.join(self.TOOLCHAIN_SRC_DIR, 'gcc', + 'gcc-%s' % self.gcc_version) + + return cmd.Chain( + cmd.MakeDir(gcc_required_dir), + cmd.Wrapper( + cmd.Chain(svn_co_command, svn_get_revision), + cwd=gcc_required_dir)) + + def CheckoutAndroidToolchain(self): + p4client = self.p4client + command = p4client.SetupAndDo(p4client.Sync(), + p4client.SaveCurrentCLNumber('CLNUM'), + p4client.Remove()) + if self.gcc_version != '4.4.3': + command.append(self._CheckoutGCCFromSVN()) + + return command + + def BuildAndroidToolchain(self): + script_cmd = self.scripts.BuildAndroidToolchain( + self.toolchain_prefix_dir, self.CHECKOUT_DIR, self.TOOLCHAIN_BUILD_DIR, + self.TOOLCHAIN_SRC_DIR) + + # Record toolchain and gcc CL number + record_cl_cmd = cmd.Copy( + os.path.join(self.CHECKOUT_DIR, 'CLNUM*'), + to_dir=self.toolchain_prefix_dir) + save_cmd = cmd.Tar( + os.path.join('$JOB_TMP', 'results', '%s.tar.bz2' % + self.toolchain_prefix_dir), self.toolchain_prefix_dir) + return cmd.Chain(script_cmd, record_cl_cmd, save_cmd) + + def _BuildAndroidTree(self, local_android_branch_dir, product): + target_tools_prefix = os.path.join('$JOB_TMP', self.toolchain_prefix_dir, + 'bin', 'arm-linux-androideabi-') + java_path = '/usr/lib/jvm/java-6-sun/bin' + build_cmd = cmd.Shell('make', '-j8', 'PRODUCT-%s-userdebug' % product, + 'TARGET_TOOLS_PREFIX=%s' % target_tools_prefix, + 'PATH=%s:$PATH' % java_path) + return cmd.Wrapper(build_cmd, cwd=local_android_branch_dir) + + def BuildAndroidImage(self, product, branch): + assert product in ['stingray', 'passion', 'trygon', 'soju'] + + # Copy the tree from atree.mtv.corp to ANDROID_TREES_DIR/branch + androidtrees_host = 'atree.mtv.corp.google.com' + androidtrees_path = ('/usr/local/google2/home/mobiletc-prebuild/' + 'android_trees') + remote_android_branch_path = os.path.join(androidtrees_path, branch) + local_android_branch_dir = os.path.join(self.ANDROID_TREES_DIR, branch) + gettree_cmd = cmd.RemoteCopyFrom( + androidtrees_host, remote_android_branch_path, local_android_branch_dir) + + # Configure and build the tree + buildtree_cmd = self._BuildAndroidTree(local_android_branch_dir, product) + + # Compress and copy system.img to result + result_system_img = os.path.join(local_android_branch_dir, 'out', 'target', + 'product', product, 'system.img') + copy_img = cmd.Copy(result_system_img, to_dir='results') + compress_img = cmd.Shell('bzip2', os.path.join('results', 'system.img')) + + return cmd.Chain(gettree_cmd, buildtree_cmd, copy_img, compress_img) + + def CheckoutScripts(self): + p4view = perforce.View('depot2', + [perforce.PathMapping('gcctools/android/tools/...', + 'tools/...')]) + p4client = perforce.CommandsFactory(self.TOOLS_DIR, p4view) + return p4client.SetupAndDo(p4client.Sync(), p4client.Remove()) + + def BuildRunBenchmark(self, arch, run_experiment): + # Copy base benchmark binaries from atree.mtv.corp + base_benchbin_host = 'atree.mtv.corp.google.com' + base_benchbin_path = ('/usr/local/google2/home/mobiletc-prebuild/' + 'archive/v3binaries/2011-10-18') + local_basebenchbin_dir = 'base_benchmark_bin' + getbase_cmd = cmd.RemoteCopyFrom(base_benchbin_host, base_benchbin_path, + local_basebenchbin_dir) + + # Build and run benchmark. + android_arch = 'android_%s' % arch + run_label = 'normal' + benchmark_cmd = self.scripts.RunBenchmark( + self.toolchain_prefix_dir, self.TOOLS_DIR, self.BENCHMARK_OUT_DIR, + run_label, run_experiment, android_arch, local_basebenchbin_dir) + + # Extract jobid from BENCHMARK_OUT_DIR/log/jobid_normal.log file. + # Copy jobid to www server to generate performance dashboard. + # TODO(jingyu) + + return cmd.Chain(getbase_cmd, benchmark_cmd) + + +class ScriptsFactory(object): + + def __init__(self, gcc_version, binutils_version, gold_version): + self._gcc_version = gcc_version + self._binutils_version = binutils_version + self._gold_version = gold_version + + def BuildAndroidToolchain(self, toolchain_prefix_dir, checkout_dir, + toolchain_build_dir, androidtc_src_dir): + if self._gcc_version == '4.4.3': + gold_option = 'both/gold' + else: + gold_option = 'default' + + return cmd.Shell( + 'build_androidtoolchain.sh', + '--toolchain-src=%s' % os.path.join('$JOB_TMP', androidtc_src_dir), + '--build-path=%s' % os.path.join('$JOB_TMP', toolchain_build_dir), + '--install-prefix=%s' % os.path.join('$JOB_TMP', toolchain_prefix_dir), + '--target=arm-linux-androideabi', + '--enable-gold=%s' % gold_option, + '--with-gcc-version=%s' % self._gcc_version, + '--with-binutils-version=%s' % self._binutils_version, + '--with-gold-version=%s' % self._gold_version, + '--with-gdb-version=7.1.x-android', + '--log-path=%s/logs' % '$JOB_HOME', + '--android-sysroot=%s' % os.path.join('$JOB_TMP', checkout_dir, + 'gcctools', 'android', 'master', + 'honeycomb_generic_sysroot'), + path=os.path.join(checkout_dir, 'gcctools', 'android', 'tools', + 'scripts')) + + def RunBenchmark(self, + toolchain_prefix_dir, + checkout_dir, + output_dir, + run_label, + run_experiment, + arch, + base_bench_bin=None): + if base_bench_bin: + base_bench_opt = '--base_benchmark_bin=%s' % base_bench_bin + else: + base_bench_opt = '' + + return cmd.Shell( + 'benchmark.sh', + '--android_toolchain=%s' % os.path.join('$JOB_TMP', + toolchain_prefix_dir), + '--bench_space=%s' % os.path.join('$JOB_TMP', 'bench'), + '--benchmark_bin=%s' % os.path.join('$JOB_TMP', output_dir, + 'bench_bin'), + base_bench_opt, + '--log_path=%s' % os.path.join('$JOB_TMP', output_dir, 'log'), + '--arch=%s' % arch, + '--run_label=%s' % run_label, + '--run_experiment=%s' % run_experiment, + path=os.path.join(checkout_dir, 'tools', 'scripts')) diff --git a/deprecated/automation/clients/helper/chromeos.py b/deprecated/automation/clients/helper/chromeos.py new file mode 100644 index 00000000..e7157451 --- /dev/null +++ b/deprecated/automation/clients/helper/chromeos.py @@ -0,0 +1,180 @@ +# Copyright 2011 Google Inc. All Rights Reserved. + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import os.path +import re + +from automation.clients.helper import jobs +from automation.clients.helper import perforce +from automation.common import command as cmd +from automation.common import machine + + +class ScriptsFactory(object): + + def __init__(self, chromeos_root, scripts_path): + self._chromeos_root = chromeos_root + self._scripts_path = scripts_path + + def SummarizeResults(self, logs_path): + return cmd.Shell('summarize_results.py', logs_path, path=self._scripts_path) + + def Buildbot(self, config_name): + buildbot = os.path.join(self._chromeos_root, + 'chromite/cbuildbot/cbuildbot.py') + + return cmd.Shell(buildbot, '--buildroot=%s' % self._chromeos_root, + '--resume', '--noarchive', '--noprebuilts', '--nosync', + '--nouprev', '--notests', '--noclean', config_name) + + def RunBenchmarks(self, board, tests): + image_path = os.path.join(self._chromeos_root, 'src/build/images', board, + 'latest/chromiumos_image.bin') + + return cmd.Shell('cros_run_benchmarks.py', + '--remote=$SECONDARY_MACHINES[0]', + '--board=%s' % board, + '--tests=%s' % tests, + '--full_table', + image_path, + path='/home/mobiletc-prebuild') + + def SetupChromeOS(self, version='latest', use_minilayout=False): + setup_chromeos = cmd.Shell('setup_chromeos.py', + '--public', + '--dir=%s' % self._chromeos_root, + '--version=%s' % version, + path=self._scripts_path) + + if use_minilayout: + setup_chromeos.AddOption('--minilayout') + return setup_chromeos + + +class CommandsFactory(object): + DEPOT2_DIR = '//depot2/' + P4_CHECKOUT_DIR = 'perforce2/' + P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, 'gcctools/chromeos/v14') + + CHROMEOS_ROOT = 'chromeos' + CHROMEOS_SCRIPTS_DIR = os.path.join(CHROMEOS_ROOT, 'src/scripts') + CHROMEOS_BUILDS_DIR = '/home/mobiletc-prebuild/www/chromeos_builds' + + def __init__(self, chromeos_version, board, toolchain, p4_snapshot): + self.chromeos_version = chromeos_version + self.board = board + self.toolchain = toolchain + self.p4_snapshot = p4_snapshot + + self.scripts = ScriptsFactory(self.CHROMEOS_ROOT, self.P4_VERSION_DIR) + + def AddBuildbotConfig(self, config_name, config_list): + config_header = 'add_config(%r, [%s])' % (config_name, + ', '.join(config_list)) + config_file = os.path.join(self.CHROMEOS_ROOT, + 'chromite/cbuildbot/cbuildbot_config.py') + quoted_config_header = '%r' % config_header + quoted_config_header = re.sub("'", "\\\"", quoted_config_header) + + return cmd.Pipe( + cmd.Shell('echo', quoted_config_header), + cmd.Shell('tee', '--append', config_file)) + + def RunBuildbot(self): + config_dict = {'board': self.board, + 'build_tests': True, + 'chrome_tests': True, + 'unittests': False, + 'vm_tests': False, + 'prebuilts': False, + 'latest_toolchain': True, + 'useflags': ['chrome_internal'], + 'usepkg_chroot': True, + self.toolchain: True} + config_name = '%s-toolchain-test' % self.board + if 'arm' in self.board: + config_list = ['arm'] + else: + config_list = [] + config_list.extend(['internal', 'full', 'official', str(config_dict)]) + + add_config_shell = self.AddBuildbotConfig(config_name, config_list) + return cmd.Chain(add_config_shell, self.scripts.Buildbot(config_name)) + + def BuildAndBenchmark(self): + return cmd.Chain( + self.CheckoutV14Dir(), + self.SetupChromeOSCheckout(self.chromeos_version, True), + self.RunBuildbot(), + self.scripts.RunBenchmarks(self.board, 'BootPerfServer,10:Page,3')) + + def GetP4Snapshot(self, p4view): + p4client = perforce.CommandsFactory(self.P4_CHECKOUT_DIR, p4view) + + if self.p4_snapshot: + return p4client.CheckoutFromSnapshot(self.p4_snapshot) + else: + return p4client.SetupAndDo(p4client.Sync(), p4client.Remove()) + + def CheckoutV14Dir(self): + p4view = perforce.View(self.DEPOT2_DIR, [ + perforce.PathMapping('gcctools/chromeos/v14/...') + ]) + return self.GetP4Snapshot(p4view) + + def SetupChromeOSCheckout(self, version, use_minilayout=False): + version_re = '^\d+\.\d+\.\d+\.[a-zA-Z0-9]+$' + + location = os.path.join(self.CHROMEOS_BUILDS_DIR, version) + + if version in ['weekly', 'quarterly']: + assert os.path.islink(location), 'Symlink %s does not exist.' % location + + location_expanded = os.path.abspath(os.path.realpath(location)) + version = os.path.basename(location_expanded) + + if version in ['top', 'latest'] or re.match(version_re, version): + return self.scripts.SetupChromeOS(version, use_minilayout) + + elif version.endswith('bz2') or version.endswith('gz'): + return cmd.UnTar(location_expanded, self.CHROMEOS_ROOT) + + else: + signature_file_location = os.path.join(location, + 'src/scripts/enter_chroot.sh') + assert os.path.exists(signature_file_location), ( + 'Signature file %s does not exist.' % signature_file_location) + + return cmd.Copy(location, to_dir=self.CHROMEOS_ROOT, recursive=True) + + +class JobsFactory(object): + + def __init__(self, + chromeos_version='top', + board='x86-mario', + toolchain='trunk', + p4_snapshot=''): + self.chromeos_version = chromeos_version + self.board = board + self.toolchain = toolchain + + self.commands = CommandsFactory(chromeos_version, board, toolchain, + p4_snapshot) + + def BuildAndBenchmark(self): + command = self.commands.BuildAndBenchmark() + + label = 'BuildAndBenchmark(%s,%s,%s)' % (self.toolchain, self.board, + self.chromeos_version) + + machine_label = 'chromeos-%s' % self.board + + job = jobs.CreateLinuxJob(label, command) + job.DependsOnMachine( + machine.MachineSpecification(label=machine_label, + lock_required=True), + False) + + return job diff --git a/deprecated/automation/clients/helper/crosstool.py b/deprecated/automation/clients/helper/crosstool.py new file mode 100644 index 00000000..80154b25 --- /dev/null +++ b/deprecated/automation/clients/helper/crosstool.py @@ -0,0 +1,168 @@ +# Copyright 2011 Google Inc. All Rights Reserved. + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import os.path +import time + +from automation.clients.helper import jobs +from automation.clients.helper import perforce +from automation.common import command as cmd +from automation.common import job + + +class JobsFactory(object): + + def __init__(self): + self.commands = CommandsFactory() + + def CheckoutCrosstool(self, target): + command = self.commands.CheckoutCrosstool() + new_job = jobs.CreateLinuxJob('CheckoutCrosstool(%s)' % target, command) + checkout_dir_dep = job.FolderDependency(new_job, + CommandsFactory.CHECKOUT_DIR) + manifests_dir_dep = job.FolderDependency( + new_job, os.path.join(self.commands.buildit_path, target), 'manifests') + return new_job, checkout_dir_dep, manifests_dir_dep + + def BuildRelease(self, checkout_dir, target): + command = self.commands.BuildRelease(target) + new_job = jobs.CreateLinuxJob('BuildRelease(%s)' % target, command) + new_job.DependsOnFolder(checkout_dir) + build_tree_dep = job.FolderDependency(new_job, + self.commands.buildit_work_dir_path) + return new_job, build_tree_dep + + def RunTests(self, checkout_dir, build_tree_dir, target, board, component): + command = self.commands.RunTests(target, board, component) + new_job = jobs.CreateLinuxJob('RunTests(%s, %s, %s)' % + (target, component, board), command) + new_job.DependsOnFolder(checkout_dir) + new_job.DependsOnFolder(build_tree_dir) + testrun_dir_dep = job.FolderDependency( + new_job, self.commands.dejagnu_output_path, board) + return new_job, testrun_dir_dep + + def GenerateReport(self, testrun_dirs, manifests_dir, target, boards): + command = self.commands.GenerateReport(boards) + new_job = jobs.CreateLinuxJob('GenerateReport(%s)' % target, command) + new_job.DependsOnFolder(manifests_dir) + for testrun_dir in testrun_dirs: + new_job.DependsOnFolder(testrun_dir) + return new_job + + +class CommandsFactory(object): + CHECKOUT_DIR = 'crosstool-checkout-dir' + + def __init__(self): + self.buildit_path = os.path.join(self.CHECKOUT_DIR, 'gcctools', 'crosstool', + 'v15') + + self.buildit_work_dir = 'buildit-tmp' + self.buildit_work_dir_path = os.path.join('$JOB_TMP', self.buildit_work_dir) + self.dejagnu_output_path = os.path.join(self.buildit_work_dir_path, + 'dejagnu-output') + + paths = { + 'gcctools': [ + 'crosstool/v15/...', 'scripts/...' + ], + 'gcctools/google_vendor_src_branch': [ + 'binutils/binutils-2.21/...', 'gdb/gdb-7.2.x/...', + 'zlib/zlib-1.2.3/...' + ], + 'gcctools/vendor_src': [ + 'gcc/google/gcc-4_6/...' + ] + } + + p4view = perforce.View('depot2', + perforce.PathMapping.ListFromPathDict(paths)) + + self.p4client = perforce.CommandsFactory(self.CHECKOUT_DIR, p4view) + + def CheckoutCrosstool(self): + p4client = self.p4client + + return p4client.SetupAndDo(p4client.Sync(), + p4client.SaveCurrentCLNumber('CLNUM'), + p4client.Remove()) + + def BuildRelease(self, target): + clnum_path = os.path.join('$JOB_TMP', self.CHECKOUT_DIR, 'CLNUM') + + toolchain_root = os.path.join('/google/data/rw/projects/toolchains', target, + 'unstable') + toolchain_path = os.path.join(toolchain_root, '${CLNUM}') + + build_toolchain = cmd.Wrapper( + cmd.Chain( + cmd.MakeDir(toolchain_path), + cmd.Shell('buildit', + '--keep-work-dir', + '--build-type=release', + '--work-dir=%s' % self.buildit_work_dir_path, + '--results-dir=%s' % toolchain_path, + '--force-release=%s' % '${CLNUM}', + target, + path='.')), + cwd=self.buildit_path, + umask='0022', + env={'CLNUM': '$(< %s)' % clnum_path}) + + # remove all but 10 most recent directories + remove_old_toolchains_from_x20 = cmd.Wrapper( + cmd.Pipe( + cmd.Shell('ls', '-1', '-r'), cmd.Shell('sed', '-e', '1,10d'), + cmd.Shell('xargs', 'rm', '-r', '-f')), + cwd=toolchain_root) + + return cmd.Chain(build_toolchain, remove_old_toolchains_from_x20) + + def RunTests(self, target, board, component='gcc'): + dejagnu_flags = ['--outdir=%s' % self.dejagnu_output_path, + '--target_board=%s' % board] + + # Look for {pandaboard,qemu}.exp files in + # //depot/google3/experimental/users/kbaclawski/dejagnu/boards + + site_exp_file = os.path.join('/google/src/head/depot/google3', + 'experimental/users/kbaclawski', + 'dejagnu/site.exp') + + build_dir_path = os.path.join(target, 'rpmbuild/BUILD/crosstool*-0.0', + 'build-%s' % component) + + run_dejagnu = cmd.Wrapper( + cmd.Chain( + cmd.MakeDir(self.dejagnu_output_path), + cmd.Shell('make', + 'check', + '-k', + '-j $(grep -c processor /proc/cpuinfo)', + 'RUNTESTFLAGS="%s"' % ' '.join(dejagnu_flags), + 'DEJAGNU="%s"' % site_exp_file, + ignore_error=True)), + cwd=os.path.join(self.buildit_work_dir_path, build_dir_path), + env={'REMOTE_TMPDIR': 'job-$JOB_ID'}) + + save_results = cmd.Copy(self.dejagnu_output_path, + to_dir='$JOB_TMP/results', + recursive=True) + + return cmd.Chain(run_dejagnu, save_results) + + def GenerateReport(self, boards): + sumfiles = [os.path.join('$JOB_TMP', board, '*.sum') for board in boards] + + return cmd.Wrapper( + cmd.Shell('dejagnu.sh', + 'report', + '-m', + '$JOB_TMP/manifests/*.xfail', + '-o', + '$JOB_TMP/results/report.html', + *sumfiles, + path='.'), + cwd='$HOME/automation/clients/report') diff --git a/deprecated/automation/clients/helper/jobs.py b/deprecated/automation/clients/helper/jobs.py new file mode 100644 index 00000000..96a1c408 --- /dev/null +++ b/deprecated/automation/clients/helper/jobs.py @@ -0,0 +1,11 @@ +# Copyright 2010 Google Inc. All Rights Reserved. + +from automation.common import job +from automation.common import machine + + +def CreateLinuxJob(label, command, lock=False, timeout=4 * 60 * 60): + to_return = job.Job(label, command, timeout) + to_return.DependsOnMachine(machine.MachineSpecification(os='linux', + lock_required=lock)) + return to_return diff --git a/deprecated/automation/clients/helper/perforce.py b/deprecated/automation/clients/helper/perforce.py new file mode 100644 index 00000000..1f2dfe79 --- /dev/null +++ b/deprecated/automation/clients/helper/perforce.py @@ -0,0 +1,215 @@ +# Copyright 2011 Google Inc. All Rights Reserved. + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import collections +import os.path + +from automation.common import command as cmd + + +class PathMapping(object): + """Stores information about relative path mapping (remote to local).""" + + @classmethod + def ListFromPathDict(cls, prefix_path_dict): + """Takes {'prefix1': ['path1',...], ...} and returns a list of mappings.""" + + mappings = [] + + for prefix, paths in sorted(prefix_path_dict.items()): + for path in sorted(paths): + mappings.append(cls(os.path.join(prefix, path))) + + return mappings + + @classmethod + def ListFromPathTuples(cls, tuple_list): + """Takes a list of tuples and returns a list of mappings. + + Args: + tuple_list: [('remote_path1', 'local_path1'), ...] + + Returns: + a list of mapping objects + """ + mappings = [] + for remote_path, local_path in tuple_list: + mappings.append(cls(remote_path, local_path)) + + return mappings + + def __init__(self, remote, local=None, common_suffix=None): + suffix = self._FixPath(common_suffix or '') + + self.remote = os.path.join(remote, suffix) + self.local = os.path.join(local or remote, suffix) + + @staticmethod + def _FixPath(path_s): + parts = [part for part in path_s.strip('/').split('/') if part] + + if not parts: + return '' + + return os.path.join(*parts) + + def _GetRemote(self): + return self._remote + + def _SetRemote(self, path_s): + self._remote = self._FixPath(path_s) + + remote = property(_GetRemote, _SetRemote) + + def _GetLocal(self): + return self._local + + def _SetLocal(self, path_s): + self._local = self._FixPath(path_s) + + local = property(_GetLocal, _SetLocal) + + def GetAbsolute(self, depot, client): + return (os.path.join('//', depot, self.remote), + os.path.join('//', client, self.local)) + + def __str__(self): + return '%s(%s => %s)' % (self.__class__.__name__, self.remote, self.local) + + +class View(collections.MutableSet): + """Keeps all information about local client required to work with perforce.""" + + def __init__(self, depot, mappings=None, client=None): + self.depot = depot + + if client: + self.client = client + + self._mappings = set(mappings or []) + + @staticmethod + def _FixRoot(root_s): + parts = root_s.strip('/').split('/', 1) + + if len(parts) != 1: + return None + + return parts[0] + + def _GetDepot(self): + return self._depot + + def _SetDepot(self, depot_s): + depot = self._FixRoot(depot_s) + assert depot, 'Not a valid depot name: "%s".' % depot_s + self._depot = depot + + depot = property(_GetDepot, _SetDepot) + + def _GetClient(self): + return self._client + + def _SetClient(self, client_s): + client = self._FixRoot(client_s) + assert client, 'Not a valid client name: "%s".' % client_s + self._client = client + + client = property(_GetClient, _SetClient) + + def add(self, mapping): + assert type(mapping) is PathMapping + self._mappings.add(mapping) + + def discard(self, mapping): + assert type(mapping) is PathMapping + self._mappings.discard(mapping) + + def __contains__(self, value): + return value in self._mappings + + def __len__(self): + return len(self._mappings) + + def __iter__(self): + return iter(mapping for mapping in self._mappings) + + def AbsoluteMappings(self): + return iter(mapping.GetAbsolute(self.depot, self.client) + for mapping in self._mappings) + + +class CommandsFactory(object): + """Creates shell commands used for interaction with Perforce.""" + + def __init__(self, checkout_dir, p4view, name=None, port=None): + self.port = port or 'perforce2:2666' + self.view = p4view + self.view.client = name or 'p4-automation-$HOSTNAME-$JOB_ID' + self.checkout_dir = checkout_dir + self.p4config_path = os.path.join(self.checkout_dir, '.p4config') + + def Initialize(self): + return cmd.Chain('mkdir -p %s' % self.checkout_dir, 'cp ~/.p4config %s' % + self.checkout_dir, 'chmod u+w %s' % self.p4config_path, + 'echo "P4PORT=%s" >> %s' % (self.port, self.p4config_path), + 'echo "P4CLIENT=%s" >> %s' % + (self.view.client, self.p4config_path)) + + def Create(self): + # TODO(kbaclawski): Could we support value list for options consistently? + mappings = ['-a \"%s %s\"' % mapping + for mapping in self.view.AbsoluteMappings()] + + # First command will create client with default mappings. Second one will + # replace default mapping with desired. Unfortunately, it seems that it + # cannot be done in one step. P4EDITOR is defined to /bin/true because we + # don't want "g4 client" to enter real editor and wait for user actions. + return cmd.Wrapper( + cmd.Chain( + cmd.Shell('g4', 'client'), + cmd.Shell('g4', 'client', '--replace', *mappings)), + env={'P4EDITOR': '/bin/true'}) + + def SaveSpecification(self, filename=None): + return cmd.Pipe(cmd.Shell('g4', 'client', '-o'), output=filename) + + def Sync(self, revision=None): + sync_arg = '...' + if revision: + sync_arg = '%s@%s' % (sync_arg, revision) + return cmd.Shell('g4', 'sync', sync_arg) + + def SaveCurrentCLNumber(self, filename=None): + return cmd.Pipe( + cmd.Shell('g4', 'changes', '-m1', '...#have'), + cmd.Shell('sed', '-E', '"s,Change ([0-9]+) .*,\\1,"'), + output=filename) + + def Remove(self): + return cmd.Shell('g4', 'client', '-d', self.view.client) + + def SetupAndDo(self, *commands): + return cmd.Chain(self.Initialize(), + self.InCheckoutDir(self.Create(), *commands)) + + def InCheckoutDir(self, *commands): + return cmd.Wrapper(cmd.Chain(*commands), cwd=self.checkout_dir) + + def CheckoutFromSnapshot(self, snapshot): + cmds = cmd.Chain() + + for mapping in self.view: + local_path, file_part = mapping.local.rsplit('/', 1) + + if file_part == '...': + remote_dir = os.path.join(snapshot, local_path) + local_dir = os.path.join(self.checkout_dir, os.path.dirname(local_path)) + + cmds.extend([ + cmd.Shell('mkdir', '-p', local_dir), cmd.Shell( + 'rsync', '-lr', remote_dir, local_dir) + ]) + + return cmds diff --git a/deprecated/automation/clients/nightly.py b/deprecated/automation/clients/nightly.py new file mode 100755 index 00000000..d35c4eca --- /dev/null +++ b/deprecated/automation/clients/nightly.py @@ -0,0 +1,51 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +import optparse +import pickle +import sys +import xmlrpclib + +from automation.clients.helper import chromeos +from automation.common import job_group + + +def Main(argv): + parser = optparse.OptionParser() + parser.add_option('-c', + '--chromeos_version', + dest='chromeos_version', + default='quarterly', + help='ChromeOS version to use.') + parser.add_option('-t', + '--toolchain', + dest='toolchain', + default='latest-toolchain', + help='Toolchain to use {latest-toolchain,gcc_46}.') + parser.add_option('-b', + '--board', + dest='board', + default='x86-generic', + help='Board to use for the nightly job.') + options = parser.parse_args(argv)[0] + + toolchain = options.toolchain + board = options.board + chromeos_version = options.chromeos_version + + # Build toolchain + jobs_factory = chromeos.JobsFactory(chromeos_version=chromeos_version, + board=board, + toolchain=toolchain) + benchmark_job = jobs_factory.BuildAndBenchmark() + + group_label = 'nightly_client_%s' % board + group = job_group.JobGroup(group_label, [benchmark_job], True, False) + + server = xmlrpclib.Server('http://localhost:8000') + server.ExecuteJobGroup(pickle.dumps(group)) + + +if __name__ == '__main__': + Main(sys.argv) diff --git a/deprecated/automation/clients/output_test.py b/deprecated/automation/clients/output_test.py new file mode 100755 index 00000000..73c26eed --- /dev/null +++ b/deprecated/automation/clients/output_test.py @@ -0,0 +1,29 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +import os.path +import pickle +import sys +import xmlrpclib + +from automation.common import job +from automation.common import job_group +from automation.common import machine + + +def Main(): + server = xmlrpclib.Server('http://localhost:8000') + + command = os.path.join( + os.path.dirname(sys.argv[0]), '../../produce_output.py') + + pwd_job = job.Job('pwd_job', command) + pwd_job.DependsOnMachine(machine.MachineSpecification(os='linux')) + + group = job_group.JobGroup('pwd_client', [pwd_job]) + server.ExecuteJobGroup(pickle.dumps(group)) + + +if __name__ == '__main__': + Main() diff --git a/deprecated/automation/clients/pwd_test.py b/deprecated/automation/clients/pwd_test.py new file mode 100755 index 00000000..493444d5 --- /dev/null +++ b/deprecated/automation/clients/pwd_test.py @@ -0,0 +1,27 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +import pickle +import xmlrpclib + +from automation.common import job +from automation.common import job_group +from automation.common import machine + + +def Main(): + server = xmlrpclib.Server('http://localhost:8000') + + command = ['echo These following 3 lines should be the same', 'pwd', '$(pwd)', + 'echo ${PWD}'] + + pwd_job = job.Job('pwd_job', ' && '.join(command)) + pwd_job.DependsOnMachine(machine.MachineSpecification(os='linux')) + + group = job_group.JobGroup('pwd_client', [pwd_job]) + server.ExecuteJobGroup(pickle.dumps(group)) + + +if __name__ == '__main__': + Main() diff --git a/deprecated/automation/clients/report/dejagnu.sh b/deprecated/automation/clients/report/dejagnu.sh new file mode 100755 index 00000000..fadd8a0c --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu.sh @@ -0,0 +1,9 @@ +#!/bin/bash +# +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +export PYTHONPATH="$(pwd)" + +python dejagnu/main.py $@ diff --git a/deprecated/automation/clients/report/dejagnu/__init__.py b/deprecated/automation/clients/report/dejagnu/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/clients/report/dejagnu/main.py b/deprecated/automation/clients/report/dejagnu/main.py new file mode 100644 index 00000000..62f095e1 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/main.py @@ -0,0 +1,137 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +from contextlib import contextmanager +import glob +from itertools import chain +import logging +import optparse +import os.path +import sys + +from manifest import Manifest +import report +from summary import DejaGnuTestRun + + +def ExpandGlobExprList(paths): + """Returns an iterator that goes over expanded glob paths.""" + return chain.from_iterable(map(glob.glob, paths)) + + +@contextmanager +def OptionChecker(parser): + """Provides scoped environment for command line option checking.""" + try: + yield + except SystemExit as ex: + parser.print_help() + print '' + sys.exit('ERROR: %s' % str(ex)) + + +def ManifestCommand(argv): + parser = optparse.OptionParser( + description= + ('Read in one or more DejaGNU summary files (.sum), parse their ' + 'content and generate manifest files. Manifest files store a list ' + 'of failed tests that should be ignored. Generated files are ' + 'stored in current directory under following name: ' + '${tool}-${board}.xfail (e.g. "gcc-unix.xfail").'), + usage='Usage: %prog manifest [file.sum] (file2.sum ...)') + + _, args = parser.parse_args(argv[2:]) + + with OptionChecker(parser): + if not args: + sys.exit('At least one *.sum file required.') + + for filename in chain.from_iterable(map(glob.glob, args)): + test_run = DejaGnuTestRun.FromFile(filename) + + manifest = Manifest.FromDejaGnuTestRun(test_run) + manifest_filename = '%s-%s.xfail' % (test_run.tool, test_run.board) + + with open(manifest_filename, 'w') as manifest_file: + manifest_file.write(manifest.Generate()) + + logging.info('Wrote manifest to "%s" file.', manifest_filename) + + +def ReportCommand(argv): + parser = optparse.OptionParser( + description= + ('Read in one or more DejaGNU summary files (.sum), parse their ' + 'content and generate a single report file in selected format ' + '(currently only HTML).'), + usage=('Usage: %prog report (-m manifest.xfail) [-o report.html] ' + '[file.sum (file2.sum ...)')) + parser.add_option( + '-o', + dest='output', + type='string', + default=None, + help=('Suppress failures for test listed in provided manifest files. ' + '(use -m for each manifest file you want to read)')) + parser.add_option( + '-m', + dest='manifests', + type='string', + action='append', + default=None, + help=('Suppress failures for test listed in provided manifest files. ' + '(use -m for each manifest file you want to read)')) + + opts, args = parser.parse_args(argv[2:]) + + with OptionChecker(parser): + if not args: + sys.exit('At least one *.sum file required.') + + if not opts.output: + sys.exit('Please provide name for report file.') + + manifests = [] + + for filename in ExpandGlobExprList(opts.manifests or []): + logging.info('Using "%s" manifest.', filename) + manifests.append(Manifest.FromFile(filename)) + + test_runs = [DejaGnuTestRun.FromFile(filename) + for filename in chain.from_iterable(map(glob.glob, args))] + + html = report.Generate(test_runs, manifests) + + if html: + with open(opts.output, 'w') as html_file: + html_file.write(html) + logging.info('Wrote report to "%s" file.', opts.output) + else: + sys.exit(1) + + +def HelpCommand(argv): + sys.exit('\n'.join([ + 'Usage: %s command [options]' % os.path.basename(argv[ + 0]), '', 'Commands:', + ' manifest - manage files containing a list of suppressed test failures', + ' report - generate report file for selected test runs' + ])) + + +def Main(argv): + try: + cmd_name = argv[1] + except IndexError: + cmd_name = None + + cmd_map = {'manifest': ManifestCommand, 'report': ReportCommand} + cmd_map.get(cmd_name, HelpCommand)(argv) + + +if __name__ == '__main__': + FORMAT = '%(asctime)-15s %(levelname)s %(message)s' + logging.basicConfig(format=FORMAT, level=logging.INFO) + + Main(sys.argv) diff --git a/deprecated/automation/clients/report/dejagnu/manifest.py b/deprecated/automation/clients/report/dejagnu/manifest.py new file mode 100644 index 00000000..5831d1b0 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/manifest.py @@ -0,0 +1,103 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +from collections import namedtuple +from cStringIO import StringIO +import logging + +from summary import DejaGnuTestResult + + +class Manifest(namedtuple('Manifest', 'tool board results')): + """Stores a list of unsuccessful tests. + + Any line that starts with '#@' marker carries auxiliary data in form of a + key-value pair, for example: + + #@ tool: * + #@ board: unix + + So far tool and board parameters are recognized. Their value can contain + arbitrary glob expression. Based on aforementioned parameters given manifest + will be applied for all test results, but only in selected test runs. Note + that all parameters are optional. Their default value is '*' (i.e. for all + tools/boards). + + The meaning of lines above is as follows: corresponding test results to follow + should only be suppressed if test run was performed on "unix" board. + + The summary line used to build the test result should have this format: + + attrlist | UNRESOLVED: gcc.dg/unroll_1.c (test for excess errors) + ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ + optional result name variant + attributes + """ + SUPPRESSIBLE_RESULTS = ['FAIL', 'UNRESOLVED', 'XPASS', 'ERROR'] + + @classmethod + def FromDejaGnuTestRun(cls, test_run): + results = [result + for result in test_run.results + if result.result in cls.SUPPRESSIBLE_RESULTS] + + return cls(test_run.tool, test_run.board, results) + + @classmethod + def FromFile(cls, filename): + """Creates manifest instance from a file in format described above.""" + params = {} + results = [] + + with open(filename, 'r') as manifest_file: + for line in manifest_file: + if line.startswith('#@'): + # parse a line with a parameter + try: + key, value = line[2:].split(':', 1) + except ValueError: + logging.warning('Malformed parameter line: "%s".', line) + else: + params[key.strip()] = value.strip() + else: + # remove comment + try: + line, _ = line.split('#', 1) + except ValueError: + pass + + line = line.strip() + + if line: + # parse a line with a test result + result = DejaGnuTestResult.FromLine(line) + + if result: + results.append(result) + else: + logging.warning('Malformed test result line: "%s".', line) + + tool = params.get('tool', '*') + board = params.get('board', '*') + + return cls(tool, board, results) + + def Generate(self): + """Dumps manifest to string.""" + text = StringIO() + + for name in ['tool', 'board']: + text.write('#@ {0}: {1}\n'.format(name, getattr(self, name))) + + text.write('\n') + + for result in sorted(self.results, key=lambda r: r.result): + text.write('{0}\n'.format(result)) + + return text.getvalue() + + def __iter__(self): + return iter(self.results) diff --git a/deprecated/automation/clients/report/dejagnu/report.html b/deprecated/automation/clients/report/dejagnu/report.html new file mode 100644 index 00000000..39b39e09 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/report.html @@ -0,0 +1,94 @@ +<link type="text/css" rel="Stylesheet" +href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.16/themes/ui-lightness/jquery-ui.css"/> + +<script type="text/javascript" src="https://www.google.com/jsapi"></script> +<script type="text/javascript"> + google.load("visualization", "1.1", {packages: ["corechart", "table"]}); + google.load("jquery", "1.6.2"); + google.load("jqueryui", "1.8.16"); + + function drawChart(name, label, table) { + var data = google.visualization.arrayToDataTable(table); + var chart = new google.visualization.PieChart( + document.getElementById(name)); + + chart.draw(data, + {title: label, pieSliceText: "value", width: 800, height: 400}); + } + + function drawTable(name, table) { + var data = google.visualization.arrayToDataTable(table); + var table = new google.visualization.Table( + document.getElementById(name)); + + table.draw(data, { + showRowNumber: false, allowHtml: true, sortColumn: 0}); + } + + google.setOnLoadCallback(function () { + $( "#testruns" ).tabs(); + + {% for test_run in test_runs %} + $( "#testrun{{ test_run.id }}" ).tabs(); + + {% for result_type, group in test_run.groups.items %} + $( "#testrun{{ test_run.id }}-{{ result_type }}-tables" ).accordion({ + autoHeight: false, collapsible: true, active: false }); + + drawChart( + "testrun{{ test_run.id }}-{{ result_type }}-chart", + "DejaGNU test {{ result_type }} summary for {{ test_run.name }}", + [ + ["Result", "Count"], + {% for result, count in group.summary %} + ["{{ result }}", {{ count }}],{% endfor %} + ]); + + {% for description, test_list in group.tests %} + {% if test_list %} + drawTable( + "testrun{{ test_run.id }}-{{ result_type }}-table-{{ forloop.counter }}", + [ + ["Test", "Variant"], + {% for test, variant in test_list %} + ["{{ test }}", "{{ variant }}"],{% endfor %} + ]); + {% endif %} + {% endfor %} + {% endfor %} + {% endfor %} + }); +</script> + +<div id="testruns"> + <ul> + {% for test_run in test_runs %} + <li><a href="#testrun{{ test_run.id }}">{{ test_run.name }}</a></li> + {% endfor %} + </ul> + + {% for test_run in test_runs %} + <div id="testrun{{ test_run.id }}" style="padding: 0px"> + <ul> + {% for result_type, group in test_run.groups.items %} + <li> + <a href="#testrun{{ test_run.id }}-{{ forloop.counter }}">{{ result_type }}</a> + </li> + {% endfor %} + </ul> + {% for result_type, group in test_run.groups.items %} + <div id="testrun{{ test_run.id }}-{{ forloop.counter }}"> + <div id="testrun{{ test_run.id }}-{{ result_type }}-chart" style="text-align: center"></div> + <div id="testrun{{ test_run.id }}-{{ result_type }}-tables"> + {% for description, test_list in group.tests %} + {% if test_list %} + <h3><a href="#">{{ description }}</a></h3> + <div id="testrun{{ test_run.id }}-{{ result_type }}-table-{{ forloop.counter }}"></div> + {% endif %} + {% endfor %} + </div> + </div> + {% endfor %} + </div> +{% endfor %} +</div> diff --git a/deprecated/automation/clients/report/dejagnu/report.py b/deprecated/automation/clients/report/dejagnu/report.py new file mode 100644 index 00000000..191a5389 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/report.py @@ -0,0 +1,115 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +import logging +import os.path + +RESULT_DESCRIPTION = { + 'ERROR': 'DejaGNU errors', + 'FAIL': 'Failed tests', + 'NOTE': 'DejaGNU notices', + 'PASS': 'Passed tests', + 'UNRESOLVED': 'Unresolved tests', + 'UNSUPPORTED': 'Unsupported tests', + 'UNTESTED': 'Not executed tests', + 'WARNING': 'DejaGNU warnings', + 'XFAIL': 'Expected test failures', + 'XPASS': 'Unexpectedly passed tests' +} + +RESULT_GROUPS = { + 'Successes': ['PASS', 'XFAIL'], + 'Failures': ['FAIL', 'XPASS', 'UNRESOLVED'], + 'Suppressed': ['!FAIL', '!XPASS', '!UNRESOLVED', '!ERROR'], + 'Framework': ['UNTESTED', 'UNSUPPORTED', 'ERROR', 'WARNING', 'NOTE'] +} + +ROOT_PATH = os.path.dirname(os.path.abspath(__file__)) + + +def _GetResultDescription(name): + if name.startswith('!'): + name = name[1:] + + try: + return RESULT_DESCRIPTION[name] + except KeyError: + raise ValueError('Unknown result: "%s"' % name) + + +def _PrepareSummary(res_types, summary): + + def GetResultCount(res_type): + return summary.get(res_type, 0) + + return [(_GetResultDescription(rt), GetResultCount(rt)) for rt in res_types] + + +def _PrepareTestList(res_types, tests): + + def GetTestsByResult(res_type): + return [(test.name, test.variant or '') + for test in sorted(tests) if test.result == res_type] + + return [(_GetResultDescription(rt), GetTestsByResult(rt)) + for rt in res_types if rt != 'PASS'] + + +def Generate(test_runs, manifests): + """Generate HTML report from provided test runs. + + Args: + test_runs: DejaGnuTestRun objects list. + manifests: Manifest object list that will drive test result suppression. + + Returns: + String to which the HTML report was rendered. + """ + tmpl_args = [] + + for test_run_id, test_run in enumerate(test_runs): + logging.info('Generating report for: %s.', test_run) + + test_run.CleanUpTestResults() + test_run.SuppressTestResults(manifests) + + # Generate summary and test list for each result group + groups = {} + + for res_group, res_types in RESULT_GROUPS.items(): + summary_all = _PrepareSummary(res_types, test_run.summary) + tests_all = _PrepareTestList(res_types, test_run.results) + + has_2nd = lambda tuple2: bool(tuple2[1]) + summary = filter(has_2nd, summary_all) + tests = filter(has_2nd, tests_all) + + if summary or tests: + groups[res_group] = {'summary': summary, 'tests': tests} + + tmpl_args.append({ + 'id': test_run_id, + 'name': '%s @%s' % (test_run.tool, test_run.board), + 'groups': groups + }) + + logging.info('Rendering report in HTML format.') + + try: + from django import template + from django.template import loader + from django.conf import settings + except ImportError: + logging.error('Django framework not installed!') + logging.error('Failed to generate report in HTML format!') + return '' + + settings.configure(DEBUG=True, + TEMPLATE_DEBUG=True, + TEMPLATE_DIRS=(ROOT_PATH,)) + + tmpl = loader.get_template('report.html') + ctx = template.Context({'test_runs': tmpl_args}) + + return tmpl.render(ctx) diff --git a/deprecated/automation/clients/report/dejagnu/summary.py b/deprecated/automation/clients/report/dejagnu/summary.py new file mode 100644 index 00000000..d573c691 --- /dev/null +++ b/deprecated/automation/clients/report/dejagnu/summary.py @@ -0,0 +1,262 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +from collections import defaultdict +from collections import namedtuple +from datetime import datetime +from fnmatch import fnmatch +from itertools import groupby +import logging +import os.path +import re + + +class DejaGnuTestResult(namedtuple('Result', 'name variant result flaky')): + """Stores the result of a single test case.""" + + # avoid adding __dict__ to the class + __slots__ = () + + LINE_RE = re.compile(r'([A-Z]+):\s+([\w/+.-]+)(.*)') + + @classmethod + def FromLine(cls, line): + """Alternate constructor which takes a string and parses it.""" + try: + attrs, line = line.split('|', 1) + + if attrs.strip() != 'flaky': + return None + + line = line.strip() + flaky = True + except ValueError: + flaky = False + + fields = cls.LINE_RE.match(line.strip()) + + if fields: + result, path, variant = fields.groups() + + # some of the tests are generated in build dir and are issued from there, + # because every test run is performed in randomly named tmp directory we + # need to remove random part + try: + # assume that 2nd field is a test path + path_parts = path.split('/') + + index = path_parts.index('testsuite') + path = '/'.join(path_parts[index + 1:]) + except ValueError: + path = '/'.join(path_parts) + + # Remove junk from test description. + variant = variant.strip(', ') + + substitutions = [ + # remove include paths - they contain name of tmp directory + ('-I\S+', ''), + # compress white spaces + ('\s+', ' ') + ] + + for pattern, replacement in substitutions: + variant = re.sub(pattern, replacement, variant) + + # Some tests separate last component of path by space, so actual filename + # ends up in description instead of path part. Correct that. + try: + first, rest = variant.split(' ', 1) + except ValueError: + pass + else: + if first.endswith('.o'): + path = os.path.join(path, first) + variant = rest + + # DejaGNU framework errors don't contain path part at all, so description + # part has to be reconstructed. + if not any(os.path.basename(path).endswith('.%s' % suffix) + for suffix in ['h', 'c', 'C', 'S', 'H', 'cc', 'i', 'o']): + variant = '%s %s' % (path, variant) + path = '' + + # Some tests are picked up from current directory (presumably DejaGNU + # generates some test files). Remove the prefix for these files. + if path.startswith('./'): + path = path[2:] + + return cls(path, variant or '', result, flaky=flaky) + + def __str__(self): + """Returns string representation of a test result.""" + if self.flaky: + fmt = 'flaky | ' + else: + fmt = '' + fmt += '{2}: {0}' + if self.variant: + fmt += ' {1}' + return fmt.format(*self) + + +class DejaGnuTestRun(object): + """Container for test results that were a part of single test run. + + The class stores also metadata related to the test run. + + Attributes: + board: Name of DejaGNU board, which was used to run the tests. + date: The date when the test run was started. + target: Target triple. + host: Host triple. + tool: The tool that was tested (e.g. gcc, binutils, g++, etc.) + results: a list of DejaGnuTestResult objects. + """ + + __slots__ = ('board', 'date', 'target', 'host', 'tool', 'results') + + def __init__(self, **kwargs): + assert all(name in self.__slots__ for name in kwargs) + + self.results = set() + self.date = kwargs.get('date', datetime.now()) + + for name in ('board', 'target', 'tool', 'host'): + setattr(self, name, kwargs.get(name, 'unknown')) + + @classmethod + def FromFile(cls, filename): + """Alternate constructor - reads a DejaGNU output file.""" + test_run = cls() + test_run.FromDejaGnuOutput(filename) + test_run.CleanUpTestResults() + return test_run + + @property + def summary(self): + """Returns a summary as {ResultType -> Count} dictionary.""" + summary = defaultdict(int) + + for r in self.results: + summary[r.result] += 1 + + return summary + + def _ParseBoard(self, fields): + self.board = fields.group(1).strip() + + def _ParseDate(self, fields): + self.date = datetime.strptime(fields.group(2).strip(), '%a %b %d %X %Y') + + def _ParseTarget(self, fields): + self.target = fields.group(2).strip() + + def _ParseHost(self, fields): + self.host = fields.group(2).strip() + + def _ParseTool(self, fields): + self.tool = fields.group(1).strip() + + def FromDejaGnuOutput(self, filename): + """Read in and parse DejaGNU output file.""" + + logging.info('Reading "%s" DejaGNU output file.', filename) + + with open(filename, 'r') as report: + lines = [line.strip() for line in report.readlines() if line.strip()] + + parsers = ((re.compile(r'Running target (.*)'), self._ParseBoard), + (re.compile(r'Test Run By (.*) on (.*)'), self._ParseDate), + (re.compile(r'=== (.*) tests ==='), self._ParseTool), + (re.compile(r'Target(\s+)is (.*)'), self._ParseTarget), + (re.compile(r'Host(\s+)is (.*)'), self._ParseHost)) + + for line in lines: + result = DejaGnuTestResult.FromLine(line) + + if result: + self.results.add(result) + else: + for regexp, parser in parsers: + fields = regexp.match(line) + if fields: + parser(fields) + break + + logging.debug('DejaGNU output file parsed successfully.') + logging.debug(self) + + def CleanUpTestResults(self): + """Remove certain test results considered to be spurious. + + 1) Large number of test reported as UNSUPPORTED are also marked as + UNRESOLVED. If that's the case remove latter result. + 2) If a test is performed on compiler output and for some reason compiler + fails, we don't want to report all failures that depend on the former. + """ + name_key = lambda v: v.name + results_by_name = sorted(self.results, key=name_key) + + for name, res_iter in groupby(results_by_name, key=name_key): + results = set(res_iter) + + # If DejaGnu was unable to compile a test it will create following result: + failed = DejaGnuTestResult(name, '(test for excess errors)', 'FAIL', + False) + + # If a test compilation failed, remove all results that are dependent. + if failed in results: + dependants = set(filter(lambda r: r.result != 'FAIL', results)) + + self.results -= dependants + + for res in dependants: + logging.info('Removed {%s} dependance.', res) + + # Remove all UNRESOLVED results that were also marked as UNSUPPORTED. + unresolved = [res._replace(result='UNRESOLVED') + for res in results if res.result == 'UNSUPPORTED'] + + for res in unresolved: + if res in self.results: + self.results.remove(res) + logging.info('Removed {%s} duplicate.', res) + + def _IsApplicable(self, manifest): + """Checks if test results need to be reconsidered based on the manifest.""" + check_list = [(self.tool, manifest.tool), (self.board, manifest.board)] + + return all(fnmatch(text, pattern) for text, pattern in check_list) + + def SuppressTestResults(self, manifests): + """Suppresses all test results listed in manifests.""" + + # Get a set of tests results that are going to be suppressed if they fail. + manifest_results = set() + + for manifest in filter(self._IsApplicable, manifests): + manifest_results |= set(manifest.results) + + suppressed_results = self.results & manifest_results + + for result in sorted(suppressed_results): + logging.debug('Result suppressed for {%s}.', result) + + new_result = '!' + result.result + + # Mark result suppression as applied. + manifest_results.remove(result) + + # Rewrite test result. + self.results.remove(result) + self.results.add(result._replace(result=new_result)) + + for result in sorted(manifest_results): + logging.warning('Result {%s} listed in manifest but not suppressed.', + result) + + def __str__(self): + return '{0}, {1} @{2} on {3}'.format(self.target, self.tool, self.board, + self.date) diff --git a/deprecated/automation/clients/report/validate_failures.py b/deprecated/automation/clients/report/validate_failures.py new file mode 100755 index 00000000..d8776ba5 --- /dev/null +++ b/deprecated/automation/clients/report/validate_failures.py @@ -0,0 +1,239 @@ +#!/usr/bin/python2 + +# Script to compare testsuite failures against a list of known-to-fail +# tests. + +# Contributed by Diego Novillo <dnovillo@google.com> +# Overhaul by Krystian Baclawski <kbaclawski@google.com> +# +# Copyright (C) 2011 Free Software Foundation, Inc. +# +# This file is part of GCC. +# +# GCC is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GCC is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING. If not, write to +# the Free Software Foundation, 51 Franklin Street, Fifth Floor, +# Boston, MA 02110-1301, USA. +"""This script provides a coarser XFAILing mechanism that requires no +detailed DejaGNU markings. This is useful in a variety of scenarios: + +- Development branches with many known failures waiting to be fixed. +- Release branches with known failures that are not considered + important for the particular release criteria used in that branch. + +The script must be executed from the toplevel build directory. When +executed it will: + +1) Determine the target built: TARGET +2) Determine the source directory: SRCDIR +3) Look for a failure manifest file in + <SRCDIR>/contrib/testsuite-management/<TARGET>.xfail +4) Collect all the <tool>.sum files from the build tree. +5) Produce a report stating: + a) Failures expected in the manifest but not present in the build. + b) Failures in the build not expected in the manifest. +6) If all the build failures are expected in the manifest, it exits + with exit code 0. Otherwise, it exits with error code 1. +""" + +import optparse +import logging +import os +import sys + +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + +from dejagnu.manifest import Manifest +from dejagnu.summary import DejaGnuTestResult +from dejagnu.summary import DejaGnuTestRun + +# Pattern for naming manifest files. The first argument should be +# the toplevel GCC source directory. The second argument is the +# target triple used during the build. +_MANIFEST_PATH_PATTERN = '%s/contrib/testsuite-management/%s.xfail' + + +def GetMakefileVars(makefile_path): + assert os.path.exists(makefile_path) + + with open(makefile_path) as lines: + kvs = [line.split('=', 1) for line in lines if '=' in line] + + return dict((k.strip(), v.strip()) for k, v in kvs) + + +def GetSumFiles(build_dir): + summaries = [] + + for root, _, filenames in os.walk(build_dir): + summaries.extend([os.path.join(root, filename) + for filename in filenames if filename.endswith('.sum')]) + + return map(os.path.normpath, summaries) + + +def ValidBuildDirectory(build_dir, target): + mandatory_paths = [build_dir, os.path.join(build_dir, 'Makefile')] + + extra_paths = [os.path.join(build_dir, target), + os.path.join(build_dir, 'build-%s' % target)] + + return (all(map(os.path.exists, mandatory_paths)) and + any(map(os.path.exists, extra_paths))) + + +def GetManifestPath(build_dir): + makefile = GetMakefileVars(os.path.join(build_dir, 'Makefile')) + srcdir = makefile['srcdir'] + target = makefile['target'] + + if not ValidBuildDirectory(build_dir, target): + target = makefile['target_alias'] + + if not ValidBuildDirectory(build_dir, target): + logging.error('%s is not a valid GCC top level build directory.', build_dir) + sys.exit(1) + + logging.info('Discovered source directory: "%s"', srcdir) + logging.info('Discovered build target: "%s"', target) + + return _MANIFEST_PATH_PATTERN % (srcdir, target) + + +def CompareResults(manifest, actual): + """Compare sets of results and return two lists: + - List of results present in MANIFEST but missing from ACTUAL. + - List of results present in ACTUAL but missing from MANIFEST. + """ + # Report all the actual results not present in the manifest. + actual_vs_manifest = actual - manifest + + # Filter out tests marked flaky. + manifest_without_flaky_tests = set(filter(lambda result: not result.flaky, + manifest)) + + # Simlarly for all the tests in the manifest. + manifest_vs_actual = manifest_without_flaky_tests - actual + + return actual_vs_manifest, manifest_vs_actual + + +def LogResults(level, results): + log_fun = getattr(logging, level) + + for num, result in enumerate(sorted(results), start=1): + log_fun(' %d) %s', num, result) + + +def CheckExpectedResults(manifest_path, build_dir): + logging.info('Reading manifest file: "%s"', manifest_path) + + manifest = set(Manifest.FromFile(manifest_path)) + + logging.info('Getting actual results from build directory: "%s"', + os.path.realpath(build_dir)) + + summaries = GetSumFiles(build_dir) + + actual = set() + + for summary in summaries: + test_run = DejaGnuTestRun.FromFile(summary) + failures = set(Manifest.FromDejaGnuTestRun(test_run)) + actual.update(failures) + + if manifest: + logging.debug('Tests expected to fail:') + LogResults('debug', manifest) + + if actual: + logging.debug('Actual test failures:') + LogResults('debug', actual) + + actual_vs_manifest, manifest_vs_actual = CompareResults(manifest, actual) + + if actual_vs_manifest: + logging.info('Build results not in the manifest:') + LogResults('info', actual_vs_manifest) + + if manifest_vs_actual: + logging.info('Manifest results not present in the build:') + LogResults('info', manifest_vs_actual) + logging.info('NOTE: This is not a failure! ', + 'It just means that the manifest expected these tests to ' + 'fail, but they worked in this configuration.') + + if actual_vs_manifest or manifest_vs_actual: + sys.exit(1) + + logging.info('No unexpected failures.') + + +def ProduceManifest(manifest_path, build_dir, overwrite): + if os.path.exists(manifest_path) and not overwrite: + logging.error('Manifest file "%s" already exists.', manifest_path) + logging.error('Use --force to overwrite.') + sys.exit(1) + + testruns = map(DejaGnuTestRun.FromFile, GetSumFiles(build_dir)) + manifests = map(Manifest.FromDejaGnuTestRun, testruns) + + with open(manifest_path, 'w') as manifest_file: + manifest_strings = [manifest.Generate() for manifest in manifests] + logging.info('Writing manifest to "%s".', manifest_path) + manifest_file.write('\n'.join(manifest_strings)) + + +def Main(argv): + parser = optparse.OptionParser(usage=__doc__) + parser.add_option( + '-b', + '--build_dir', + dest='build_dir', + action='store', + metavar='PATH', + default=os.getcwd(), + help='Build directory to check. (default: current directory)') + parser.add_option('-m', + '--manifest', + dest='manifest', + action='store_true', + help='Produce the manifest for the current build.') + parser.add_option( + '-f', + '--force', + dest='force', + action='store_true', + help=('Overwrite an existing manifest file, if user requested creating ' + 'new one. (default: False)')) + parser.add_option('-v', + '--verbose', + dest='verbose', + action='store_true', + help='Increase verbosity.') + options, _ = parser.parse_args(argv[1:]) + + if options.verbose: + logging.root.setLevel(logging.DEBUG) + + manifest_path = GetManifestPath(options.build_dir) + + if options.manifest: + ProduceManifest(manifest_path, options.build_dir, options.force) + else: + CheckExpectedResults(manifest_path, options.build_dir) + + +if __name__ == '__main__': + logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO) + Main(sys.argv) diff --git a/deprecated/automation/common/__init__.py b/deprecated/automation/common/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/common/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/common/command.py b/deprecated/automation/common/command.py new file mode 100644 index 00000000..c56e9fad --- /dev/null +++ b/deprecated/automation/common/command.py @@ -0,0 +1,241 @@ +# Copyright 2011 Google Inc. All Rights Reserved. + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import abc +import collections +import os.path + + +class Shell(object): + """Class used to build a string representation of a shell command.""" + + def __init__(self, cmd, *args, **kwargs): + assert all(key in ['path', 'ignore_error'] for key in kwargs) + + self._cmd = cmd + self._args = list(args) + self._path = kwargs.get('path', '') + self._ignore_error = bool(kwargs.get('ignore_error', False)) + + def __str__(self): + cmdline = [os.path.join(self._path, self._cmd)] + cmdline.extend(self._args) + + cmd = ' '.join(cmdline) + + if self._ignore_error: + cmd = '{ %s; true; }' % cmd + + return cmd + + def AddOption(self, option): + self._args.append(option) + + +class Wrapper(object): + """Wraps a command with environment which gets cleaned up after execution.""" + + _counter = 1 + + def __init__(self, command, cwd=None, env=None, umask=None): + # @param cwd: temporary working directory + # @param env: dictionary of environment variables + self._command = command + self._prefix = Chain() + self._suffix = Chain() + + if cwd: + self._prefix.append(Shell('pushd', cwd)) + self._suffix.insert(0, Shell('popd')) + + if env: + for env_var, value in env.items(): + self._prefix.append(Shell('%s=%s' % (env_var, value))) + self._suffix.insert(0, Shell('unset', env_var)) + + if umask: + umask_save_var = 'OLD_UMASK_%d' % self.counter + + self._prefix.append(Shell('%s=$(umask)' % umask_save_var)) + self._prefix.append(Shell('umask', umask)) + self._suffix.insert(0, Shell('umask', '$%s' % umask_save_var)) + + @property + def counter(self): + counter = self._counter + self._counter += 1 + return counter + + def __str__(self): + return str(Chain(self._prefix, self._command, self._suffix)) + + +class AbstractCommandContainer(collections.MutableSequence): + """Common base for all classes that behave like command container.""" + + def __init__(self, *commands): + self._commands = list(commands) + + def __contains__(self, command): + return command in self._commands + + def __iter__(self): + return iter(self._commands) + + def __len__(self): + return len(self._commands) + + def __getitem__(self, index): + return self._commands[index] + + def __setitem__(self, index, command): + self._commands[index] = self._ValidateCommandType(command) + + def __delitem__(self, index): + del self._commands[index] + + def insert(self, index, command): + self._commands.insert(index, self._ValidateCommandType(command)) + + @abc.abstractmethod + def __str__(self): + pass + + @abc.abstractproperty + def stored_types(self): + pass + + def _ValidateCommandType(self, command): + if type(command) not in self.stored_types: + raise TypeError('Command cannot have %s type.' % type(command)) + else: + return command + + def _StringifyCommands(self): + cmds = [] + + for cmd in self: + if isinstance(cmd, AbstractCommandContainer) and len(cmd) > 1: + cmds.append('{ %s; }' % cmd) + else: + cmds.append(str(cmd)) + + return cmds + + +class Chain(AbstractCommandContainer): + """Container that chains shell commands using (&&) shell operator.""" + + @property + def stored_types(self): + return [str, Shell, Chain, Pipe] + + def __str__(self): + return ' && '.join(self._StringifyCommands()) + + +class Pipe(AbstractCommandContainer): + """Container that chains shell commands using pipe (|) operator.""" + + def __init__(self, *commands, **kwargs): + assert all(key in ['input', 'output'] for key in kwargs) + + AbstractCommandContainer.__init__(self, *commands) + + self._input = kwargs.get('input', None) + self._output = kwargs.get('output', None) + + @property + def stored_types(self): + return [str, Shell] + + def __str__(self): + pipe = self._StringifyCommands() + + if self._input: + pipe.insert(str(Shell('cat', self._input), 0)) + + if self._output: + pipe.append(str(Shell('tee', self._output))) + + return ' | '.join(pipe) + +# TODO(kbaclawski): Unfortunately we don't have any policy describing which +# directories can or cannot be touched by a job. Thus, I cannot decide how to +# protect a system against commands that are considered to be dangerous (like +# RmTree("${HOME}")). AFAIK we'll have to execute some commands with root access +# (especially for ChromeOS related jobs, which involve chroot-ing), which is +# even more scary. + + +def Copy(*args, **kwargs): + assert all(key in ['to_dir', 'recursive'] for key in kwargs.keys()) + + options = [] + + if 'to_dir' in kwargs: + options.extend(['-t', kwargs['to_dir']]) + + if 'recursive' in kwargs: + options.append('-r') + + options.extend(args) + + return Shell('cp', *options) + + +def RemoteCopyFrom(from_machine, from_path, to_path, username=None): + from_path = os.path.expanduser(from_path) + '/' + to_path = os.path.expanduser(to_path) + '/' + + if not username: + login = from_machine + else: + login = '%s@%s' % (username, from_machine) + + return Chain( + MakeDir(to_path), Shell('rsync', '-a', '%s:%s' % + (login, from_path), to_path)) + + +def MakeSymlink(to_path, link_name): + return Shell('ln', '-f', '-s', '-T', to_path, link_name) + + +def MakeDir(*dirs, **kwargs): + options = ['-p'] + + mode = kwargs.get('mode', None) + + if mode: + options.extend(['-m', str(mode)]) + + options.extend(dirs) + + return Shell('mkdir', *options) + + +def RmTree(*dirs): + return Shell('rm', '-r', '-f', *dirs) + + +def UnTar(tar_file, dest_dir): + return Chain( + MakeDir(dest_dir), Shell('tar', '-x', '-f', tar_file, '-C', dest_dir)) + + +def Tar(tar_file, *args): + options = ['-c'] + + if tar_file.endswith('.tar.bz2'): + options.append('-j') + elif tar_file.endswith('.tar.gz'): + options.append('-z') + else: + assert tar_file.endswith('.tar') + + options.extend(['-f', tar_file]) + options.extend(args) + + return Chain(MakeDir(os.path.dirname(tar_file)), Shell('tar', *options)) diff --git a/deprecated/automation/common/command_executer.py b/deprecated/automation/common/command_executer.py new file mode 100644 index 00000000..c0f314f5 --- /dev/null +++ b/deprecated/automation/common/command_executer.py @@ -0,0 +1,230 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# +"""Classes that help running commands in a subshell. + +Commands can be run locally, or remotly using SSH connection. You may log the +output of a command to a terminal or a file, or any other destination. +""" + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import fcntl +import logging +import os +import select +import subprocess +import time + +from automation.common import logger + + +class CommandExecuter(object): + DRY_RUN = False + + def __init__(self, dry_run=False): + self._logger = logging.getLogger(self.__class__.__name__) + self._dry_run = dry_run or self.DRY_RUN + + @classmethod + def Configure(cls, dry_run): + cls.DRY_RUN = dry_run + + def RunCommand(self, + cmd, + machine=None, + username=None, + command_terminator=None, + command_timeout=None): + cmd = str(cmd) + + if self._dry_run: + return 0 + + if not command_terminator: + command_terminator = CommandTerminator() + + if command_terminator.IsTerminated(): + self._logger.warning('Command has been already terminated!') + return 1 + + # Rewrite command for remote execution. + if machine: + if username: + login = '%s@%s' % (username, machine) + else: + login = machine + + self._logger.debug("Executing '%s' on %s.", cmd, login) + + # FIXME(asharif): Remove this after crosbug.com/33007 is fixed. + cmd = "ssh -t -t %s -- '%s'" % (login, cmd) + else: + self._logger.debug("Executing: '%s'.", cmd) + + child = self._SpawnProcess(cmd, command_terminator, command_timeout) + + self._logger.debug('{PID: %d} Finished with %d code.', child.pid, + child.returncode) + + return child.returncode + + def _Terminate(self, child, command_timeout, wait_timeout=10): + """Gracefully shutdown the child by sending SIGTERM.""" + + if command_timeout: + self._logger.warning('{PID: %d} Timeout of %s seconds reached since ' + 'process started.', child.pid, command_timeout) + + self._logger.warning('{PID: %d} Terminating child.', child.pid) + + try: + child.terminate() + except OSError: + pass + + wait_started = time.time() + + while not child.poll(): + if time.time() - wait_started >= wait_timeout: + break + time.sleep(0.1) + + return child.poll() + + def _Kill(self, child): + """Kill the child with immediate result.""" + self._logger.warning('{PID: %d} Process still alive.', child.pid) + self._logger.warning('{PID: %d} Killing child.', child.pid) + child.kill() + child.wait() + + def _SpawnProcess(self, cmd, command_terminator, command_timeout): + # Create a child process executing provided command. + child = subprocess.Popen(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + stdin=subprocess.PIPE, + shell=True) + + # Close stdin so the child won't be able to block on read. + child.stdin.close() + + started_time = time.time() + + # Watch for data on process stdout, stderr. + pipes = [child.stdout, child.stderr] + + # Put pipes into non-blocking mode. + for pipe in pipes: + fd = pipe.fileno() + fd_flags = fcntl.fcntl(fd, fcntl.F_GETFL) + fcntl.fcntl(fd, fcntl.F_SETFL, fd_flags | os.O_NONBLOCK) + + already_terminated = False + + while pipes: + # Maybe timeout reached? + if command_timeout and time.time() - started_time > command_timeout: + command_terminator.Terminate() + + # Check if terminate request was received. + if command_terminator.IsTerminated() and not already_terminated: + if not self._Terminate(child, command_timeout): + self._Kill(child) + # Don't exit the loop immediately. Firstly try to read everything that + # was left on stdout and stderr. + already_terminated = True + + # Wait for pipes to become ready. + ready_pipes, _, _ = select.select(pipes, [], [], 0.1) + + # Handle file descriptors ready to be read. + for pipe in ready_pipes: + fd = pipe.fileno() + + data = os.read(fd, 4096) + + # check for end-of-file + if not data: + pipes.remove(pipe) + continue + + # read all data that's available + while data: + if pipe == child.stdout: + self.DataReceivedOnOutput(data) + elif pipe == child.stderr: + self.DataReceivedOnError(data) + + try: + data = os.read(fd, 4096) + except OSError: + # terminate loop if EWOULDBLOCK (EAGAIN) is received + data = '' + + if not already_terminated: + self._logger.debug('Waiting for command to finish.') + child.wait() + + return child + + def DataReceivedOnOutput(self, data): + """Invoked when the child process wrote data to stdout.""" + sys.stdout.write(data) + + def DataReceivedOnError(self, data): + """Invoked when the child process wrote data to stderr.""" + sys.stderr.write(data) + + +class LoggingCommandExecuter(CommandExecuter): + + def __init__(self, *args, **kwargs): + super(LoggingCommandExecuter, self).__init__(*args, **kwargs) + + # Create a logger for command's stdout/stderr streams. + self._output = logging.getLogger('%s.%s' % (self._logger.name, 'Output')) + + def OpenLog(self, log_path): + """The messages are going to be saved to gzip compressed file.""" + formatter = logging.Formatter('%(asctime)s %(prefix)s: %(message)s', + '%Y-%m-%d %H:%M:%S') + handler = logger.CompressedFileHandler(log_path, delay=True) + handler.setFormatter(formatter) + self._output.addHandler(handler) + + # Set a flag to prevent log records from being propagated up the logger + # hierarchy tree. We don't want for command output messages to appear in + # the main log. + self._output.propagate = 0 + + def CloseLog(self): + """Remove handlers and reattach the logger to its parent.""" + for handler in list(self._output.handlers): + self._output.removeHandler(handler) + handler.flush() + handler.close() + + self._output.propagate = 1 + + def DataReceivedOnOutput(self, data): + """Invoked when the child process wrote data to stdout.""" + for line in data.splitlines(): + self._output.info(line, extra={'prefix': 'STDOUT'}) + + def DataReceivedOnError(self, data): + """Invoked when the child process wrote data to stderr.""" + for line in data.splitlines(): + self._output.warning(line, extra={'prefix': 'STDERR'}) + + +class CommandTerminator(object): + + def __init__(self): + self.terminated = False + + def Terminate(self): + self.terminated = True + + def IsTerminated(self): + return self.terminated diff --git a/deprecated/automation/common/command_executer_test.py b/deprecated/automation/common/command_executer_test.py new file mode 100755 index 00000000..2caaa146 --- /dev/null +++ b/deprecated/automation/common/command_executer_test.py @@ -0,0 +1,210 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import cStringIO +import logging +import os +import signal +import socket +import sys +import time +import unittest + + +def AddScriptDirToPath(): + """Required for remote python script execution.""" + path = os.path.abspath(__file__) + + for _ in range(3): + path, _ = os.path.split(path) + + if not path in sys.path: + sys.path.append(path) + + +AddScriptDirToPath() + +from automation.common.command_executer import CommandExecuter + + +class LoggerMock(object): + + def LogCmd(self, cmd, machine='', user=''): + if machine: + logging.info('[%s] Executing: %s', machine, cmd) + else: + logging.info('Executing: %s', cmd) + + def LogError(self, msg): + logging.error(msg) + + def LogWarning(self, msg): + logging.warning(msg) + + def LogOutput(self, msg): + logging.info(msg) + + +class CommandExecuterUnderTest(CommandExecuter): + + def __init__(self): + CommandExecuter.__init__(self, logger_to_set=LoggerMock()) + + # We will record stdout and stderr. + self._stderr = cStringIO.StringIO() + self._stdout = cStringIO.StringIO() + + @property + def stdout(self): + return self._stdout.getvalue() + + @property + def stderr(self): + return self._stderr.getvalue() + + def DataReceivedOnOutput(self, data): + self._stdout.write(data) + + def DataReceivedOnError(self, data): + self._stderr.write(data) + + +class CommandExecuterLocalTests(unittest.TestCase): + HOSTNAME = None + + def setUp(self): + self._executer = CommandExecuterUnderTest() + + def tearDown(self): + pass + + def RunCommand(self, method, **kwargs): + program = os.path.abspath(sys.argv[0]) + + return self._executer.RunCommand('%s runHelper %s' % (program, method), + machine=self.HOSTNAME, + **kwargs) + + def testCommandTimeout(self): + exit_code = self.RunCommand('SleepForMinute', command_timeout=3) + + self.assertTrue(-exit_code in [signal.SIGTERM, signal.SIGKILL], + 'Invalid exit code: %d' % exit_code) + + def testCommandTimeoutIfSigTermIgnored(self): + exit_code = self.RunCommand('IgnoreSigTerm', command_timeout=3) + + self.assertTrue(-exit_code in [signal.SIGTERM, signal.SIGKILL]) + + def testCommandSucceeded(self): + self.assertFalse(self.RunCommand('ReturnTrue')) + + def testCommandFailed(self): + self.assertTrue(self.RunCommand('ReturnFalse')) + + def testStringOnOutputStream(self): + self.assertFalse(self.RunCommand('EchoToOutputStream')) + self.assertEquals(self._executer.stderr, '') + self.assertEquals(self._executer.stdout, 'test') + + def testStringOnErrorStream(self): + self.assertFalse(self.RunCommand('EchoToErrorStream')) + self.assertEquals(self._executer.stderr, 'test') + self.assertEquals(self._executer.stdout, '') + + def testOutputStreamNonInteractive(self): + self.assertFalse( + self.RunCommand('IsOutputStreamInteractive'), + 'stdout stream is a terminal!') + + def testErrorStreamNonInteractive(self): + self.assertFalse( + self.RunCommand('IsErrorStreamInteractive'), + 'stderr stream is a terminal!') + + def testAttemptToRead(self): + self.assertFalse(self.RunCommand('WaitForInput', command_timeout=3)) + + def testInterruptedProcess(self): + self.assertEquals(self.RunCommand('TerminateBySigAbrt'), -signal.SIGABRT) + + +class CommandExecuterRemoteTests(CommandExecuterLocalTests): + HOSTNAME = socket.gethostname() + + def testCommandTimeoutIfSigTermIgnored(self): + exit_code = self.RunCommand('IgnoreSigTerm', command_timeout=6) + + self.assertEquals(exit_code, 255) + + lines = self._executer.stdout.splitlines() + pid = int(lines[0]) + + try: + with open('/proc/%d/cmdline' % pid) as f: + cmdline = f.read() + except IOError: + cmdline = '' + + self.assertFalse('IgnoreSigTerm' in cmdline, 'Process is still alive.') + + +class CommandExecuterTestHelpers(object): + + def SleepForMinute(self): + time.sleep(60) + return 1 + + def ReturnTrue(self): + return 0 + + def ReturnFalse(self): + return 1 + + def EchoToOutputStream(self): + sys.stdout.write('test') + return 0 + + def EchoToErrorStream(self): + sys.stderr.write('test') + return 0 + + def IsOutputStreamInteractive(self): + return sys.stdout.isatty() + + def IsErrorStreamInteractive(self): + return sys.stderr.isatty() + + def IgnoreSigTerm(self): + os.write(1, '%d' % os.getpid()) + signal.signal(signal.SIGTERM, signal.SIG_IGN) + time.sleep(30) + return 0 + + def WaitForInput(self): + try: + # can only read end-of-file marker + return os.read(0, 1) != '' + except OSError: + # that means that stdin descriptor is closed + return 0 + + def TerminateBySigAbrt(self): + os.kill(os.getpid(), signal.SIGABRT) + return 0 + + +if __name__ == '__main__': + FORMAT = '%(asctime)-15s %(levelname)s %(message)s' + logging.basicConfig(format=FORMAT, level=logging.DEBUG) + + if len(sys.argv) > 1: + if sys.argv[1] == 'runHelper': + helpers = CommandExecuterTestHelpers() + sys.exit(getattr(helpers, sys.argv[2])()) + + unittest.main() diff --git a/deprecated/automation/common/events.py b/deprecated/automation/common/events.py new file mode 100644 index 00000000..ad3ec844 --- /dev/null +++ b/deprecated/automation/common/events.py @@ -0,0 +1,149 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2011 Google Inc. All Rights Reserved. +# +"""Tools for recording and reporting timeline of abstract events. + +You can store any events provided that they can be stringified. +""" + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import collections +import datetime +import time + + +class _EventRecord(object): + """Internal class. Attaches extra information to an event.""" + + def __init__(self, event, time_started=None, time_elapsed=None): + self._event = event + self._time_started = time_started or time.time() + self._time_elapsed = None + + if time_elapsed: + self.time_elapsed = time_elapsed + + @property + def event(self): + return self._event + + @property + def time_started(self): + return self._time_started + + def _TimeElapsedGet(self): + if self.has_finished: + time_elapsed = self._time_elapsed + else: + time_elapsed = time.time() - self._time_started + + return datetime.timedelta(seconds=time_elapsed) + + def _TimeElapsedSet(self, time_elapsed): + if isinstance(time_elapsed, datetime.timedelta): + self._time_elapsed = time_elapsed.seconds + else: + self._time_elapsed = time_elapsed + + time_elapsed = property(_TimeElapsedGet, _TimeElapsedSet) + + @property + def has_finished(self): + return self._time_elapsed is not None + + def GetTimeStartedFormatted(self): + return time.strftime('%m/%d/%Y %H:%M:%S', time.gmtime(self._time_started)) + + def GetTimeElapsedRounded(self): + return datetime.timedelta(seconds=int(self.time_elapsed.seconds)) + + def Finish(self): + if not self.has_finished: + self._time_elapsed = time.time() - self._time_started + + +class _Transition(collections.namedtuple('_Transition', ('from_', 'to_'))): + """Internal class. Represents transition point between events / states.""" + + def __str__(self): + return '%s => %s' % (self.from_, self.to_) + + +class EventHistory(collections.Sequence): + """Records events and provides human readable events timeline.""" + + def __init__(self, records=None): + self._records = records or [] + + def __len__(self): + return len(self._records) + + def __iter__(self): + return iter(self._records) + + def __getitem__(self, index): + return self._records[index] + + @property + def last(self): + if self._records: + return self._records[-1] + + def AddEvent(self, event): + if self.last: + self.last.Finish() + + evrec = _EventRecord(event) + self._records.append(evrec) + return evrec + + def GetTotalTime(self): + if self._records: + total_time_elapsed = sum(evrec.time_elapsed.seconds + for evrec in self._records) + + return datetime.timedelta(seconds=int(total_time_elapsed)) + + def GetTransitionEventHistory(self): + records = [] + + if self._records: + for num, next_evrec in enumerate(self._records[1:], start=1): + evrec = self._records[num - 1] + + records.append(_EventRecord( + _Transition(evrec.event, next_evrec.event), evrec.time_started, + evrec.time_elapsed)) + + if not self.last.has_finished: + records.append(_EventRecord( + _Transition(self.last.event, + 'NOW'), self.last.time_started, self.last.time_elapsed)) + + return EventHistory(records) + + @staticmethod + def _GetReport(history, report_name): + report = [report_name] + + for num, evrec in enumerate(history, start=1): + time_elapsed = str(evrec.GetTimeElapsedRounded()) + + if not evrec.has_finished: + time_elapsed.append(' (not finished)') + + report.append('%d) %s: %s: %s' % (num, evrec.GetTimeStartedFormatted(), + evrec.event, time_elapsed)) + + report.append('Total Time: %s' % history.GetTotalTime()) + + return '\n'.join(report) + + def GetEventReport(self): + return EventHistory._GetReport(self, 'Timeline of events:') + + def GetTransitionEventReport(self): + return EventHistory._GetReport(self.GetTransitionEventHistory(), + 'Timeline of transition events:') diff --git a/deprecated/automation/common/job.py b/deprecated/automation/common/job.py new file mode 100644 index 00000000..e845ab25 --- /dev/null +++ b/deprecated/automation/common/job.py @@ -0,0 +1,178 @@ +# Copyright 2010 Google Inc. All Rights Reserved. +# +"""A module for a job in the infrastructure.""" + +__author__ = 'raymes@google.com (Raymes Khoury)' + +import os.path + +from automation.common import state_machine + +STATUS_NOT_EXECUTED = 'NOT_EXECUTED' +STATUS_SETUP = 'SETUP' +STATUS_COPYING = 'COPYING' +STATUS_RUNNING = 'RUNNING' +STATUS_SUCCEEDED = 'SUCCEEDED' +STATUS_FAILED = 'FAILED' + + +class FolderDependency(object): + + def __init__(self, job, src, dest=None): + if not dest: + dest = src + + # TODO(kbaclawski): rename to producer + self.job = job + self.src = src + self.dest = dest + + @property + def read_only(self): + return self.dest == self.src + + +class JobStateMachine(state_machine.BasicStateMachine): + state_machine = { + STATUS_NOT_EXECUTED: [STATUS_SETUP], + STATUS_SETUP: [STATUS_COPYING, STATUS_FAILED], + STATUS_COPYING: [STATUS_RUNNING, STATUS_FAILED], + STATUS_RUNNING: [STATUS_SUCCEEDED, STATUS_FAILED] + } + + final_states = [STATUS_SUCCEEDED, STATUS_FAILED] + + +class JobFailure(Exception): + + def __init__(self, message, exit_code): + Exception.__init__(self, message) + self.exit_code = exit_code + + +class Job(object): + """A class representing a job whose commands will be executed.""" + + WORKDIR_PREFIX = '/usr/local/google/tmp/automation' + + def __init__(self, label, command, timeout=4 * 60 * 60): + self._state = JobStateMachine(STATUS_NOT_EXECUTED) + self.predecessors = set() + self.successors = set() + self.machine_dependencies = [] + self.folder_dependencies = [] + self.id = 0 + self.machines = [] + self.command = command + self._has_primary_machine_spec = False + self.group = None + self.dry_run = None + self.label = label + self.timeout = timeout + + def _StateGet(self): + return self._state + + def _StateSet(self, new_state): + self._state.Change(new_state) + + status = property(_StateGet, _StateSet) + + @property + def timeline(self): + return self._state.timeline + + def __repr__(self): + return '{%s: %s}' % (self.__class__.__name__, self.id) + + def __str__(self): + res = [] + res.append('%d' % self.id) + res.append('Predecessors:') + res.extend(['%d' % pred.id for pred in self.predecessors]) + res.append('Successors:') + res.extend(['%d' % succ.id for succ in self.successors]) + res.append('Machines:') + res.extend(['%s' % machine for machine in self.machines]) + res.append(self.PrettyFormatCommand()) + res.append('%s' % self.status) + res.append(self.timeline.GetTransitionEventReport()) + return '\n'.join(res) + + @staticmethod + def _FormatCommand(cmd, substitutions): + for pattern, replacement in substitutions: + cmd = cmd.replace(pattern, replacement) + + return cmd + + def GetCommand(self): + substitutions = [ + ('$JOB_ID', str(self.id)), ('$JOB_TMP', self.work_dir), + ('$JOB_HOME', self.home_dir), + ('$PRIMARY_MACHINE', self.primary_machine.hostname) + ] + + if len(self.machines) > 1: + for num, machine in enumerate(self.machines[1:]): + substitutions.append(('$SECONDARY_MACHINES[%d]' % num, machine.hostname + )) + + return self._FormatCommand(str(self.command), substitutions) + + def PrettyFormatCommand(self): + # TODO(kbaclawski): This method doesn't belong here, but rather to + # non existing Command class. If one is created then PrettyFormatCommand + # shall become its method. + return self._FormatCommand(self.GetCommand(), [ + ('\{ ', ''), ('; \}', ''), ('\} ', '\n'), ('\s*&&\s*', '\n') + ]) + + def DependsOnFolder(self, dependency): + self.folder_dependencies.append(dependency) + self.DependsOn(dependency.job) + + @property + def results_dir(self): + return os.path.join(self.work_dir, 'results') + + @property + def logs_dir(self): + return os.path.join(self.home_dir, 'logs') + + @property + def log_filename_prefix(self): + return 'job-%d.log' % self.id + + @property + def work_dir(self): + return os.path.join(self.WORKDIR_PREFIX, 'job-%d' % self.id) + + @property + def home_dir(self): + return os.path.join(self.group.home_dir, 'job-%d' % self.id) + + @property + def primary_machine(self): + return self.machines[0] + + def DependsOn(self, job): + """Specifies Jobs to be finished before this job can be launched.""" + self.predecessors.add(job) + job.successors.add(self) + + @property + def is_ready(self): + """Check that all our dependencies have been executed.""" + return all(pred.status == STATUS_SUCCEEDED for pred in self.predecessors) + + def DependsOnMachine(self, machine_spec, primary=True): + # Job will run on arbitrarily chosen machine specified by + # MachineSpecification class instances passed to this method. + if primary: + if self._has_primary_machine_spec: + raise RuntimeError('Only one primary machine specification allowed.') + self._has_primary_machine_spec = True + self.machine_dependencies.insert(0, machine_spec) + else: + self.machine_dependencies.append(machine_spec) diff --git a/deprecated/automation/common/job_group.py b/deprecated/automation/common/job_group.py new file mode 100644 index 00000000..96912fc1 --- /dev/null +++ b/deprecated/automation/common/job_group.py @@ -0,0 +1,73 @@ +# Copyright 2010 Google Inc. All Rights Reserved. +# + +import getpass +import os + +from automation.common.state_machine import BasicStateMachine + +STATUS_NOT_EXECUTED = 'NOT_EXECUTED' +STATUS_EXECUTING = 'EXECUTING' +STATUS_SUCCEEDED = 'SUCCEEDED' +STATUS_FAILED = 'FAILED' + + +class JobGroupStateMachine(BasicStateMachine): + state_machine = { + STATUS_NOT_EXECUTED: [STATUS_EXECUTING], + STATUS_EXECUTING: [STATUS_SUCCEEDED, STATUS_FAILED] + } + + final_states = [STATUS_SUCCEEDED, STATUS_FAILED] + + +class JobGroup(object): + HOMEDIR_PREFIX = os.path.join('/home', getpass.getuser(), 'www', 'automation') + + def __init__(self, + label, + jobs=None, + cleanup_on_completion=True, + cleanup_on_failure=False, + description=''): + self._state = JobGroupStateMachine(STATUS_NOT_EXECUTED) + self.id = 0 + self.label = label + self.jobs = [] + self.cleanup_on_completion = cleanup_on_completion + self.cleanup_on_failure = cleanup_on_failure + self.description = description + + if jobs: + for job in jobs: + self.AddJob(job) + + def _StateGet(self): + return self._state + + def _StateSet(self, new_state): + self._state.Change(new_state) + + status = property(_StateGet, _StateSet) + + @property + def home_dir(self): + return os.path.join(self.HOMEDIR_PREFIX, 'job-group-%d' % self.id) + + @property + def time_submitted(self): + try: + return self.status.timeline[1].time_started + except IndexError: + return None + + def __repr__(self): + return '{%s: %s}' % (self.__class__.__name__, self.id) + + def __str__(self): + return '\n'.join(['Job-Group:', 'ID: %s' % self.id] + [str( + job) for job in self.jobs]) + + def AddJob(self, job): + self.jobs.append(job) + job.group = self diff --git a/deprecated/automation/common/logger.py b/deprecated/automation/common/logger.py new file mode 100644 index 00000000..4aeee052 --- /dev/null +++ b/deprecated/automation/common/logger.py @@ -0,0 +1,144 @@ +# Copyright 2010 Google Inc. All Rights Reserved. + +from itertools import chain +import gzip +import logging +import logging.handlers +import time +import traceback + + +def SetUpRootLogger(filename=None, level=None, display_flags={}): + console_handler = logging.StreamHandler() + console_handler.setFormatter(CustomFormatter(AnsiColorCoder(), display_flags)) + logging.root.addHandler(console_handler) + + if filename: + file_handler = logging.handlers.RotatingFileHandler( + filename, + maxBytes=10 * 1024 * 1024, + backupCount=9, + delay=True) + file_handler.setFormatter(CustomFormatter(NullColorCoder(), display_flags)) + logging.root.addHandler(file_handler) + + if level: + logging.root.setLevel(level) + + +class NullColorCoder(object): + + def __call__(self, *args): + return '' + + +class AnsiColorCoder(object): + CODES = {'reset': (0,), + 'bold': (1, 22), + 'italics': (3, 23), + 'underline': (4, 24), + 'inverse': (7, 27), + 'strikethrough': (9, 29), + 'black': (30, 40), + 'red': (31, 41), + 'green': (32, 42), + 'yellow': (33, 43), + 'blue': (34, 44), + 'magenta': (35, 45), + 'cyan': (36, 46), + 'white': (37, 47)} + + def __call__(self, *args): + codes = [] + + for arg in args: + if arg.startswith('bg-') or arg.startswith('no-'): + codes.append(self.CODES[arg[3:]][1]) + else: + codes.append(self.CODES[arg][0]) + + return '\033[%sm' % ';'.join(map(str, codes)) + + +class CustomFormatter(logging.Formatter): + COLORS = {'DEBUG': ('white',), + 'INFO': ('green',), + 'WARN': ('yellow', 'bold'), + 'ERROR': ('red', 'bold'), + 'CRIT': ('red', 'inverse', 'bold')} + + def __init__(self, coder, display_flags={}): + items = [] + + if display_flags.get('datetime', True): + items.append('%(asctime)s') + if display_flags.get('level', True): + items.append('%(levelname)s') + if display_flags.get('name', True): + items.append(coder('cyan') + '[%(threadName)s:%(name)s]' + coder('reset')) + items.append('%(prefix)s%(message)s') + + logging.Formatter.__init__(self, fmt=' '.join(items)) + + self._coder = coder + + def formatTime(self, record): + ct = self.converter(record.created) + t = time.strftime('%Y-%m-%d %H:%M:%S', ct) + return '%s.%02d' % (t, record.msecs / 10) + + def formatLevelName(self, record): + if record.levelname in ['WARNING', 'CRITICAL']: + levelname = record.levelname[:4] + else: + levelname = record.levelname + + return ''.join([self._coder(*self.COLORS[levelname]), levelname, + self._coder('reset')]) + + def formatMessagePrefix(self, record): + try: + return ' %s%s:%s ' % (self._coder('black', 'bold'), record.prefix, + self._coder('reset')) + except AttributeError: + return '' + + def format(self, record): + if record.exc_info: + if not record.exc_text: + record.exc_text = self.formatException(record.exc_info) + else: + record.exc_text = '' + + fmt = record.__dict__.copy() + fmt.update({'levelname': self.formatLevelName(record), + 'asctime': self.formatTime(record), + 'prefix': self.formatMessagePrefix(record)}) + + s = [] + + for line in chain(record.getMessage().splitlines(), + record.exc_text.splitlines()): + fmt['message'] = line + + s.append(self._fmt % fmt) + + return '\n'.join(s) + + +class CompressedFileHandler(logging.FileHandler): + + def _open(self): + return gzip.open(self.baseFilename + '.gz', self.mode, 9) + + +def HandleUncaughtExceptions(fun): + """Catches all exceptions that would go outside decorated fun scope.""" + + def _Interceptor(*args, **kwargs): + try: + return fun(*args, **kwargs) + except StandardError: + logging.exception('Uncaught exception:') + + return _Interceptor diff --git a/deprecated/automation/common/machine.py b/deprecated/automation/common/machine.py new file mode 100644 index 00000000..4db0db0d --- /dev/null +++ b/deprecated/automation/common/machine.py @@ -0,0 +1,70 @@ +# Copyright 2010 Google Inc. All Rights Reserved. + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +from fnmatch import fnmatch + + +class Machine(object): + """Stores information related to machine and its state.""" + + def __init__(self, hostname, label, cpu, cores, os, username): + self.hostname = hostname + self.label = label + self.cpu = cpu + self.cores = cores + self.os = os + self.username = username + + # MachineManager related attributes. + self.uses = 0 + self.locked = False + + def Acquire(self, exclusively): + assert not self.locked + + if exclusively: + self.locked = True + self.uses += 1 + + def Release(self): + assert self.uses > 0 + + self.uses -= 1 + + if not self.uses: + self.locked = False + + def __repr__(self): + return '{%s: %s@%s}' % (self.__class__.__name__, self.username, + self.hostname) + + def __str__(self): + return '\n'.join( + ['Machine Information:', 'Hostname: %s' % self.hostname, 'Label: %s' % + self.label, 'CPU: %s' % self.cpu, 'Cores: %d' % self.cores, 'OS: %s' % + self.os, 'Uses: %d' % self.uses, 'Locked: %s' % self.locked]) + + +class MachineSpecification(object): + """Helper class used to find a machine matching your requirements.""" + + def __init__(self, hostname='*', label='*', os='*', lock_required=False): + self.hostname = hostname + self.label = label + self.os = os + self.lock_required = lock_required + self.preferred_machines = [] + + def __str__(self): + return '\n'.join(['Machine Specification:', 'Name: %s' % self.name, 'OS: %s' + % self.os, 'Lock required: %s' % self.lock_required]) + + def IsMatch(self, machine): + return all([not machine.locked, fnmatch(machine.hostname, self.hostname), + fnmatch(machine.label, self.label), fnmatch(machine.os, + self.os)]) + + def AddPreferredMachine(self, hostname): + if hostname not in self.preferred_machines: + self.preferred_machines.append(hostname) diff --git a/deprecated/automation/common/machine_test.py b/deprecated/automation/common/machine_test.py new file mode 100755 index 00000000..f66299f5 --- /dev/null +++ b/deprecated/automation/common/machine_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Machine manager unittest. + +MachineManagerTest tests MachineManager. +""" + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import machine +import unittest + + +class MachineTest(unittest.TestCase): + + def setUp(self): + pass + + def testPrintMachine(self): + mach = machine.Machine('ahmad.mtv', 'core2duo', 4, 'linux', 'asharif') + self.assertTrue('ahmad.mtv' in str(mach)) + + +if __name__ == '__main__': + unittest.main() diff --git a/deprecated/automation/common/state_machine.py b/deprecated/automation/common/state_machine.py new file mode 100644 index 00000000..d1cf42c8 --- /dev/null +++ b/deprecated/automation/common/state_machine.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2011 Google Inc. All Rights Reserved. +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +from automation.common import events + + +class BasicStateMachine(object): + """Generic class for constructing state machines. + + Keeps all states and possible transition of a state machine. Ensures that + transition between two states is always valid. Also stores transition events + in a timeline object. + """ + state_machine = {} + final_states = [] + + def __init__(self, initial_state): + assert initial_state in self.state_machine,\ + 'Initial state does not belong to this state machine' + + self._state = initial_state + + self.timeline = events.EventHistory() + self.timeline.AddEvent(self._state) + + def __str__(self): + return self._state + + def __eq__(self, value): + if isinstance(value, BasicStateMachine): + value = str(value) + + return self._state == value + + def __ne__(self, value): + return not self == value + + def _TransitionAllowed(self, to_state): + return to_state in self.state_machine.get(self._state, []) + + def Change(self, new_state): + assert self._TransitionAllowed(new_state),\ + 'Transition from %s to %s not possible' % (self._state, new_state) + + self._state = new_state + + self.timeline.AddEvent(self._state) + + if self._state in self.final_states: + self.timeline.last.Finish() diff --git a/deprecated/automation/server/__init__.py b/deprecated/automation/server/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/server/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/server/job_executer.py b/deprecated/automation/server/job_executer.py new file mode 100644 index 00000000..30b59463 --- /dev/null +++ b/deprecated/automation/server/job_executer.py @@ -0,0 +1,138 @@ +# Copyright 2010 Google Inc. All Rights Reserved. +# + +import logging +import os.path +import threading + +from automation.common import command as cmd +from automation.common import job +from automation.common import logger +from automation.common.command_executer import LoggingCommandExecuter +from automation.common.command_executer import CommandTerminator + + +class JobExecuter(threading.Thread): + + def __init__(self, job_to_execute, machines, listeners): + threading.Thread.__init__(self) + + assert machines + + self.job = job_to_execute + self.listeners = listeners + self.machines = machines + + # Set Thread name. + self.name = '%s-%s' % (self.__class__.__name__, self.job.id) + + self._logger = logging.getLogger(self.__class__.__name__) + self._executer = LoggingCommandExecuter(self.job.dry_run) + self._terminator = CommandTerminator() + + def _RunRemotely(self, command, fail_msg, command_timeout=1 * 60 * 60): + exit_code = self._executer.RunCommand(command, + self.job.primary_machine.hostname, + self.job.primary_machine.username, + command_terminator=self._terminator, + command_timeout=command_timeout) + if exit_code: + raise job.JobFailure(fail_msg, exit_code) + + def _RunLocally(self, command, fail_msg, command_timeout=1 * 60 * 60): + exit_code = self._executer.RunCommand(command, + command_terminator=self._terminator, + command_timeout=command_timeout) + if exit_code: + raise job.JobFailure(fail_msg, exit_code) + + def Kill(self): + self._terminator.Terminate() + + def CleanUpWorkDir(self): + self._logger.debug('Cleaning up %r work directory.', self.job) + self._RunRemotely(cmd.RmTree(self.job.work_dir), 'Cleanup workdir failed.') + + def CleanUpHomeDir(self): + self._logger.debug('Cleaning up %r home directory.', self.job) + self._RunLocally(cmd.RmTree(self.job.home_dir), 'Cleanup homedir failed.') + + def _PrepareRuntimeEnvironment(self): + self._RunRemotely( + cmd.MakeDir(self.job.work_dir, self.job.logs_dir, self.job.results_dir), + 'Creating new job directory failed.') + + # The log directory is ready, so we can prepare to log command's output. + self._executer.OpenLog(os.path.join(self.job.logs_dir, + self.job.log_filename_prefix)) + + def _SatisfyFolderDependencies(self): + for dependency in self.job.folder_dependencies: + to_folder = os.path.join(self.job.work_dir, dependency.dest) + from_folder = os.path.join(dependency.job.work_dir, dependency.src) + from_machine = dependency.job.primary_machine + + if from_machine == self.job.primary_machine and dependency.read_only: + # No need to make a copy, just symlink it + self._RunRemotely( + cmd.MakeSymlink(from_folder, to_folder), + 'Failed to create symlink to required directory.') + else: + self._RunRemotely( + cmd.RemoteCopyFrom(from_machine.hostname, + from_folder, + to_folder, + username=from_machine.username), + 'Failed to copy required files.') + + def _LaunchJobCommand(self): + command = self.job.GetCommand() + + self._RunRemotely('%s; %s' % ('PS1=. TERM=linux source ~/.bashrc', + cmd.Wrapper(command, + cwd=self.job.work_dir)), + "Command failed to execute: '%s'." % command, + self.job.timeout) + + def _CopyJobResults(self): + """Copy test results back to directory.""" + self._RunLocally( + cmd.RemoteCopyFrom(self.job.primary_machine.hostname, + self.job.results_dir, + self.job.home_dir, + username=self.job.primary_machine.username), + 'Failed to copy results.') + + def run(self): + self.job.status = job.STATUS_SETUP + self.job.machines = self.machines + self._logger.debug('Executing %r on %r in directory %s.', self.job, + self.job.primary_machine.hostname, self.job.work_dir) + + try: + self.CleanUpWorkDir() + + self._PrepareRuntimeEnvironment() + + self.job.status = job.STATUS_COPYING + + self._SatisfyFolderDependencies() + + self.job.status = job.STATUS_RUNNING + + self._LaunchJobCommand() + self._CopyJobResults() + + # If we get here, the job succeeded. + self.job.status = job.STATUS_SUCCEEDED + except job.JobFailure as ex: + self._logger.error('Job failed. Exit code %s. %s', ex.exit_code, ex) + if self._terminator.IsTerminated(): + self._logger.info('%r was killed', self.job) + + self.job.status = job.STATUS_FAILED + + self._executer.CloseLog() + + for listener in self.listeners: + listener.NotifyJobComplete(self.job) diff --git a/deprecated/automation/server/job_group_manager.py b/deprecated/automation/server/job_group_manager.py new file mode 100644 index 00000000..d66f5e07 --- /dev/null +++ b/deprecated/automation/server/job_group_manager.py @@ -0,0 +1,118 @@ +# Copyright 2010 Google Inc. All Rights Reserved. +# + +import copy +import logging +import threading + +from automation.common import command as cmd +from automation.common import logger +from automation.common.command_executer import CommandExecuter +from automation.common import job +from automation.common import job_group +from automation.server.job_manager import IdProducerPolicy + + +class JobGroupManager(object): + + def __init__(self, job_manager): + self.all_job_groups = [] + + self.job_manager = job_manager + self.job_manager.AddListener(self) + + self._lock = threading.Lock() + self._job_group_finished = threading.Condition(self._lock) + + self._id_producer = IdProducerPolicy() + self._id_producer.Initialize(job_group.JobGroup.HOMEDIR_PREFIX, + 'job-group-(?P<id>\d+)') + + self._logger = logging.getLogger(self.__class__.__name__) + + def GetJobGroup(self, group_id): + with self._lock: + for group in self.all_job_groups: + if group.id == group_id: + return group + + return None + + def GetAllJobGroups(self): + with self._lock: + return copy.deepcopy(self.all_job_groups) + + def AddJobGroup(self, group): + with self._lock: + group.id = self._id_producer.GetNextId() + + self._logger.debug('Creating runtime environment for %r.', group) + + CommandExecuter().RunCommand(cmd.Chain( + cmd.RmTree(group.home_dir), cmd.MakeDir(group.home_dir))) + + with self._lock: + self.all_job_groups.append(group) + + for job_ in group.jobs: + self.job_manager.AddJob(job_) + + group.status = job_group.STATUS_EXECUTING + + self._logger.info('Added %r to queue.', group) + + return group.id + + def KillJobGroup(self, group): + with self._lock: + self._logger.debug('Killing all jobs that belong to %r.', group) + + for job_ in group.jobs: + self.job_manager.KillJob(job_) + + self._logger.debug('Waiting for jobs to quit.') + + # Lets block until the group is killed so we know it is completed + # when we return. + while group.status not in [job_group.STATUS_SUCCEEDED, + job_group.STATUS_FAILED]: + self._job_group_finished.wait() + + def NotifyJobComplete(self, job_): + self._logger.debug('Handling %r completion event.', job_) + + group = job_.group + + with self._lock: + # We need to perform an action only if the group hasn't already failed. + if group.status != job_group.STATUS_FAILED: + if job_.status == job.STATUS_FAILED: + # We have a failed job, abort the job group + group.status = job_group.STATUS_FAILED + if group.cleanup_on_failure: + for job_ in group.jobs: + # TODO(bjanakiraman): We should probably only kill dependent jobs + # instead of the whole job group. + self.job_manager.KillJob(job_) + self.job_manager.CleanUpJob(job_) + else: + # The job succeeded successfully -- lets check to see if we are done. + assert job_.status == job.STATUS_SUCCEEDED + finished = True + for other_job in group.jobs: + assert other_job.status != job.STATUS_FAILED + if other_job.status != job.STATUS_SUCCEEDED: + finished = False + break + + if finished and group.status != job_group.STATUS_SUCCEEDED: + # TODO(kbaclawski): Without check performed above following code + # could be called more than once. This would trigger StateMachine + # crash, because it cannot transition from STATUS_SUCCEEDED to + # STATUS_SUCCEEDED. Need to address that bug in near future. + group.status = job_group.STATUS_SUCCEEDED + if group.cleanup_on_completion: + for job_ in group.jobs: + self.job_manager.CleanUpJob(job_) + + self._job_group_finished.notifyAll() diff --git a/deprecated/automation/server/job_manager.py b/deprecated/automation/server/job_manager.py new file mode 100644 index 00000000..7a65b918 --- /dev/null +++ b/deprecated/automation/server/job_manager.py @@ -0,0 +1,194 @@ +# Copyright 2010 Google Inc. All Rights Reserved. +# + +import logging +import os +import re +import threading + +from automation.common import job +from automation.common import logger +from automation.server.job_executer import JobExecuter + + +class IdProducerPolicy(object): + """Produces series of unique integer IDs. + + Example: + id_producer = IdProducerPolicy() + id_a = id_producer.GetNextId() + id_b = id_producer.GetNextId() + assert id_a != id_b + """ + + def __init__(self): + self._counter = 1 + + def Initialize(self, home_prefix, home_pattern): + """Find first available ID based on a directory listing. + + Args: + home_prefix: A directory to be traversed. + home_pattern: A regexp describing all files/directories that will be + considered. The regexp must contain exactly one match group with name + "id", which must match an integer number. + + Example: + id_producer.Initialize(JOBDIR_PREFIX, 'job-(?P<id>\d+)') + """ + harvested_ids = [] + + if os.path.isdir(home_prefix): + for filename in os.listdir(home_prefix): + path = os.path.join(home_prefix, filename) + + if os.path.isdir(path): + match = re.match(home_pattern, filename) + + if match: + harvested_ids.append(int(match.group('id'))) + + self._counter = max(harvested_ids or [0]) + 1 + + def GetNextId(self): + """Calculates another ID considered to be unique.""" + new_id = self._counter + self._counter += 1 + return new_id + + +class JobManager(threading.Thread): + + def __init__(self, machine_manager): + threading.Thread.__init__(self, name=self.__class__.__name__) + self.all_jobs = [] + self.ready_jobs = [] + self.job_executer_mapping = {} + + self.machine_manager = machine_manager + + self._lock = threading.Lock() + self._jobs_available = threading.Condition(self._lock) + self._exit_request = False + + self.listeners = [] + self.listeners.append(self) + + self._id_producer = IdProducerPolicy() + self._id_producer.Initialize(job.Job.WORKDIR_PREFIX, 'job-(?P<id>\d+)') + + self._logger = logging.getLogger(self.__class__.__name__) + + def StartJobManager(self): + self._logger.info('Starting...') + + with self._lock: + self.start() + self._jobs_available.notifyAll() + + def StopJobManager(self): + self._logger.info('Shutdown request received.') + + with self._lock: + for job_ in self.all_jobs: + self._KillJob(job_.id) + + # Signal to die + self._exit_request = True + self._jobs_available.notifyAll() + + # Wait for all job threads to finish + for executer in self.job_executer_mapping.values(): + executer.join() + + def KillJob(self, job_id): + """Kill a job by id. + + Does not block until the job is completed. + """ + with self._lock: + self._KillJob(job_id) + + def GetJob(self, job_id): + for job_ in self.all_jobs: + if job_.id == job_id: + return job_ + return None + + def _KillJob(self, job_id): + self._logger.info('Killing [Job: %d].', job_id) + + if job_id in self.job_executer_mapping: + self.job_executer_mapping[job_id].Kill() + for job_ in self.ready_jobs: + if job_.id == job_id: + self.ready_jobs.remove(job_) + break + + def AddJob(self, job_): + with self._lock: + job_.id = self._id_producer.GetNextId() + + self.all_jobs.append(job_) + # Only queue a job as ready if it has no dependencies + if job_.is_ready: + self.ready_jobs.append(job_) + + self._jobs_available.notifyAll() + + return job_.id + + def CleanUpJob(self, job_): + with self._lock: + if job_.id in self.job_executer_mapping: + self.job_executer_mapping[job_.id].CleanUpWorkDir() + del self.job_executer_mapping[job_.id] + # TODO(raymes): remove job from self.all_jobs + + def NotifyJobComplete(self, job_): + self.machine_manager.ReturnMachines(job_.machines) + + with self._lock: + self._logger.debug('Handling %r completion event.', job_) + + if job_.status == job.STATUS_SUCCEEDED: + for succ in job_.successors: + if succ.is_ready: + if succ not in self.ready_jobs: + self.ready_jobs.append(succ) + + self._jobs_available.notifyAll() + + def AddListener(self, listener): + self.listeners.append(listener) + + @logger.HandleUncaughtExceptions + def run(self): + self._logger.info('Started.') + + while not self._exit_request: + with self._lock: + # Get the next ready job, block if there are none + self._jobs_available.wait() + + while self.ready_jobs: + ready_job = self.ready_jobs.pop() + + required_machines = ready_job.machine_dependencies + for pred in ready_job.predecessors: + required_machines[0].AddPreferredMachine( + pred.primary_machine.hostname) + + machines = self.machine_manager.GetMachines(required_machines) + if not machines: + # If we can't get the necessary machines right now, simply wait + # for some jobs to complete + self.ready_jobs.insert(0, ready_job) + break + else: + # Mark as executing + executer = JobExecuter(ready_job, machines, self.listeners) + executer.start() + self.job_executer_mapping[ready_job.id] = executer + + self._logger.info('Stopped.') diff --git a/deprecated/automation/server/machine_manager.py b/deprecated/automation/server/machine_manager.py new file mode 100644 index 00000000..b7186077 --- /dev/null +++ b/deprecated/automation/server/machine_manager.py @@ -0,0 +1,77 @@ +# Copyright 2010 Google Inc. All Rights Reserved. + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +from operator import attrgetter +import copy +import csv +import threading +import os.path + +from automation.common import machine + +DEFAULT_MACHINES_FILE = os.path.join(os.path.dirname(__file__), 'test_pool.csv') + + +class MachineManager(object): + """Container for list of machines one can run jobs on.""" + + @classmethod + def FromMachineListFile(cls, filename): + # Read the file and skip header + csv_file = csv.reader(open(filename, 'rb'), delimiter=',', quotechar='"') + csv_file.next() + + return cls([machine.Machine(hostname, label, cpu, int(cores), os, user) + for hostname, label, cpu, cores, os, user in csv_file]) + + def __init__(self, machines): + self._machine_pool = machines + self._lock = threading.RLock() + + def _GetMachine(self, mach_spec): + available_pool = [m for m in self._machine_pool if mach_spec.IsMatch(m)] + + if available_pool: + # find a machine with minimum uses + uses = attrgetter('uses') + + mach = min(available_pool, key=uses) + + if mach_spec.preferred_machines: + preferred_pool = [m + for m in available_pool + if m.hostname in mach_spec.preferred_machines] + if preferred_pool: + mach = min(preferred_pool, key=uses) + + mach.Acquire(mach_spec.lock_required) + + return mach + + def GetMachines(self, required_machines): + """Acquire machines for use by a job.""" + + with self._lock: + acquired_machines = [self._GetMachine(ms) for ms in required_machines] + + if not all(acquired_machines): + # Roll back acquires + while acquired_machines: + mach = acquired_machines.pop() + if mach: + mach.Release() + + return acquired_machines + + def GetMachineList(self): + with self._lock: + return copy.deepcopy(self._machine_pool) + + def ReturnMachines(self, machines): + with self._lock: + for m in machines: + m.Release() + + def __str__(self): + return str(self._machine_pool) diff --git a/deprecated/automation/server/machine_manager_test.py b/deprecated/automation/server/machine_manager_test.py new file mode 100755 index 00000000..2fa5bb4b --- /dev/null +++ b/deprecated/automation/server/machine_manager_test.py @@ -0,0 +1,32 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import unittest +from automation.common import machine +from automation.server import machine_manager + + +class MachineManagerTest(unittest.TestCase): + + def setUp(self): + self.machine_manager = machine_manager.MachineManager() + + def testPrint(self): + print self.machine_manager + + def testGetLinuxBox(self): + mach_spec_list = [machine.MachineSpecification(os='linux')] + machines = self.machine_manager.GetMachines(mach_spec_list) + self.assertTrue(machines) + + def testGetChromeOSBox(self): + mach_spec_list = [machine.MachineSpecification(os='chromeos')] + machines = self.machine_manager.GetMachines(mach_spec_list) + self.assertTrue(machines) + + +if __name__ == '__main__': + unittest.main() diff --git a/deprecated/automation/server/monitor/__init__.py b/deprecated/automation/server/monitor/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/automation/server/monitor/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/automation/server/monitor/dashboard.py b/deprecated/automation/server/monitor/dashboard.py new file mode 100644 index 00000000..f6befed8 --- /dev/null +++ b/deprecated/automation/server/monitor/dashboard.py @@ -0,0 +1,259 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +from collections import namedtuple +import glob +import gzip +import os.path +import pickle +import time +import xmlrpclib + +from django import forms +from django.http import HttpResponseRedirect +from django.shortcuts import render_to_response +from django.template import Context +from django.views import static + +Link = namedtuple('Link', 'href name') + + +def GetServerConnection(): + return xmlrpclib.Server('http://localhost:8000') + + +def MakeDefaultContext(*args): + context = Context({'links': [ + Link('/job-group', 'Job Groups'), Link('/machine', 'Machines') + ]}) + + for arg in args: + context.update(arg) + + return context + + +class JobInfo(object): + + def __init__(self, job_id): + self._job = pickle.loads(GetServerConnection().GetJob(job_id)) + + def GetAttributes(self): + job = self._job + + group = [Link('/job-group/%d' % job.group.id, job.group.label)] + + predecessors = [Link('/job/%d' % pred.id, pred.label) + for pred in job.predecessors] + + successors = [Link('/job/%d' % succ.id, succ.label) + for succ in job.successors] + + machines = [Link('/machine/%s' % mach.hostname, mach.hostname) + for mach in job.machines] + + logs = [Link('/job/%d/log' % job.id, 'Log')] + + commands = enumerate(job.PrettyFormatCommand().split('\n'), start=1) + + return {'text': [('Label', job.label), ('Directory', job.work_dir)], + 'link': [('Group', group), ('Predecessors', predecessors), + ('Successors', successors), ('Machines', machines), + ('Logs', logs)], + 'code': [('Command', commands)]} + + def GetTimeline(self): + return [{'started': evlog.GetTimeStartedFormatted(), + 'state_from': evlog.event.from_, + 'state_to': evlog.event.to_, + 'elapsed': evlog.GetTimeElapsedRounded()} + for evlog in self._job.timeline.GetTransitionEventHistory()] + + def GetLog(self): + log_path = os.path.join(self._job.logs_dir, + '%s.gz' % self._job.log_filename_prefix) + + try: + log = gzip.open(log_path, 'r') + except IOError: + content = [] + else: + # There's a good chance that file is not closed yet, so EOF handling + # function and CRC calculation will fail, thus we need to monkey patch the + # _read_eof method. + log._read_eof = lambda: None + + def SplitLine(line): + prefix, msg = line.split(': ', 1) + datetime, stream = prefix.rsplit(' ', 1) + + return datetime, stream, msg + + content = map(SplitLine, log.readlines()) + finally: + log.close() + + return content + + +class JobGroupInfo(object): + + def __init__(self, job_group_id): + self._job_group = pickle.loads(GetServerConnection().GetJobGroup( + job_group_id)) + + def GetAttributes(self): + group = self._job_group + + home_dir = [Link('/job-group/%d/files/' % group.id, group.home_dir)] + + return {'text': [('Label', group.label), + ('Time submitted', time.ctime(group.time_submitted)), + ('State', group.status), + ('Cleanup on completion', group.cleanup_on_completion), + ('Cleanup on failure', group.cleanup_on_failure)], + 'link': [('Directory', home_dir)]} + + def _GetJobStatus(self, job): + status_map = {'SUCCEEDED': 'success', 'FAILED': 'failure'} + return status_map.get(str(job.status), None) + + def GetJobList(self): + return [{'id': job.id, + 'label': job.label, + 'state': job.status, + 'status': self._GetJobStatus(job), + 'elapsed': job.timeline.GetTotalTime()} + for job in self._job_group.jobs] + + def GetHomeDirectory(self): + return self._job_group.home_dir + + def GetReportList(self): + job_dir_pattern = os.path.join(self._job_group.home_dir, 'job-*') + + filenames = [] + + for job_dir in glob.glob(job_dir_pattern): + filename = os.path.join(job_dir, 'report.html') + + if os.access(filename, os.F_OK): + filenames.append(filename) + + reports = [] + + for filename in sorted(filenames, key=lambda f: os.stat(f).st_ctime): + try: + with open(filename, 'r') as report: + reports.append(report.read()) + except IOError: + pass + + return reports + + +class JobGroupListInfo(object): + + def __init__(self): + self._all_job_groups = pickle.loads(GetServerConnection().GetAllJobGroups()) + + def _GetJobGroupState(self, group): + return str(group.status) + + def _GetJobGroupStatus(self, group): + status_map = {'SUCCEEDED': 'success', 'FAILED': 'failure'} + return status_map.get(self._GetJobGroupState(group), None) + + def GetList(self): + return [{'id': group.id, + 'label': group.label, + 'submitted': time.ctime(group.time_submitted), + 'state': self._GetJobGroupState(group), + 'status': self._GetJobGroupStatus(group)} + for group in self._all_job_groups] + + def GetLabelList(self): + return sorted(set(group.label for group in self._all_job_groups)) + + +def JobPageHandler(request, job_id): + job = JobInfo(int(job_id)) + + ctx = MakeDefaultContext({ + 'job_id': job_id, + 'attributes': job.GetAttributes(), + 'timeline': job.GetTimeline() + }) + + return render_to_response('job.html', ctx) + + +def LogPageHandler(request, job_id): + job = JobInfo(int(job_id)) + + ctx = MakeDefaultContext({'job_id': job_id, 'log_lines': job.GetLog()}) + + return render_to_response('job_log.html', ctx) + + +def JobGroupPageHandler(request, job_group_id): + group = JobGroupInfo(int(job_group_id)) + + ctx = MakeDefaultContext({ + 'group_id': job_group_id, + 'attributes': group.GetAttributes(), + 'job_list': group.GetJobList(), + 'reports': group.GetReportList() + }) + + return render_to_response('job_group.html', ctx) + + +def JobGroupFilesPageHandler(request, job_group_id, path): + group = JobGroupInfo(int(job_group_id)) + + return static.serve(request, + path, + document_root=group.GetHomeDirectory(), + show_indexes=True) + + +class FilterJobGroupsForm(forms.Form): + label = forms.ChoiceField(label='Filter by label:', required=False) + + +def JobGroupListPageHandler(request): + groups = JobGroupListInfo() + group_list = groups.GetList() + + field = FilterJobGroupsForm.base_fields['label'] + field.choices = [('*', '--- no filtering ---')] + field.choices.extend([(label, label) for label in groups.GetLabelList()]) + + if request.method == 'POST': + form = FilterJobGroupsForm(request.POST) + + if form.is_valid(): + label = form.cleaned_data['label'] + + if label != '*': + group_list = [group for group in group_list if group['label'] == label] + else: + form = FilterJobGroupsForm({'initial': '*'}) + + ctx = MakeDefaultContext({'filter': form, 'groups': group_list}) + + return render_to_response('job_group_list.html', ctx) + + +def MachineListPageHandler(request): + machine_list = pickle.loads(GetServerConnection().GetMachineList()) + + return render_to_response('machine_list.html', + MakeDefaultContext({'machines': machine_list})) + + +def DefaultPageHandler(request): + return HttpResponseRedirect('/job-group') diff --git a/deprecated/automation/server/monitor/manage.py b/deprecated/automation/server/monitor/manage.py new file mode 100755 index 00000000..59f6e216 --- /dev/null +++ b/deprecated/automation/server/monitor/manage.py @@ -0,0 +1,20 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +from django.core.management import execute_manager + +try: + import settings # Assumed to be in the same directory. +except ImportError: + import sys + + sys.stderr.write('Error: Can\'t find settings.py file in the directory ' + 'containing %r.' % __file__) + sys.exit(1) + +if __name__ == '__main__': + execute_manager(settings) diff --git a/deprecated/automation/server/monitor/settings.py b/deprecated/automation/server/monitor/settings.py new file mode 100644 index 00000000..8cd20e35 --- /dev/null +++ b/deprecated/automation/server/monitor/settings.py @@ -0,0 +1,49 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# +# Django settings for monitor project. +# +# For explanation look here: http://docs.djangoproject.com/en/dev/ref/settings +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +import os.path +import sys + +# Path to the root of application. It's a custom setting, not related to Django. +ROOT_PATH = os.path.dirname(os.path.realpath(sys.argv[0])) + +# Print useful information during runtime if possible. +DEBUG = True +TEMPLATE_DEBUG = DEBUG + +# Sqlite3 database configuration, though we don't use it right now. +DATABASE_ENGINE = 'sqlite3' +DATABASE_NAME = os.path.join(ROOT_PATH, 'monitor.db') + +# Local time zone for this installation. +TIME_ZONE = 'America/Los_Angeles' + +# Language code for this installation. +LANGUAGE_CODE = 'en-us' + +# If you set this to False, Django will make some optimizations so as not +# to load the internationalization machinery. +USE_I18N = True + +# Absolute path to the directory that holds media. +MEDIA_ROOT = os.path.join(ROOT_PATH, 'static') + '/' + +# URL that handles the media served from MEDIA_ROOT. Make sure to use a +# trailing slash if there is a path component (optional in other cases). +MEDIA_URL = '/static/' + +# Used to provide a seed in secret-key hashing algorithms. Make this unique, +# and don't share it with anybody. +SECRET_KEY = '13p5p_4q91*8@yo+tvvt#2k&6#d_&e_zvxdpdil53k419i5sop' + +# A string representing the full Python import path to your root URLconf. +ROOT_URLCONF = 'monitor.urls' + +# List of locations of the template source files, in search order. +TEMPLATE_DIRS = (os.path.join(ROOT_PATH, 'templates'),) diff --git a/deprecated/automation/server/monitor/start.sh b/deprecated/automation/server/monitor/start.sh new file mode 100755 index 00000000..4fc53bef --- /dev/null +++ b/deprecated/automation/server/monitor/start.sh @@ -0,0 +1,7 @@ +#!/bin/bash +# +# Copyright 2011 Google Inc. All Rights Reserved. +# Author: kbaclawski@google.com (Krystian Baclawski) +# + +./manage.py runserver "$HOSTNAME":8080 diff --git a/deprecated/automation/server/monitor/static/style.css b/deprecated/automation/server/monitor/static/style.css new file mode 100644 index 00000000..b571b059 --- /dev/null +++ b/deprecated/automation/server/monitor/static/style.css @@ -0,0 +1,101 @@ +* { font-family: sans-serif; } + +.left { text-align: left; } +.right { text-align: right; } + +.code { font-family: monospace; text-align: left; } +.line1 { background-color: Gainsboro; } +.line2 { background-color: WhiteSmoke; } + +.title { margin-bottom: 0.25em; } + +.success { background-color: LightGreen; } +.failure { background-color: LightPink; } + +pre.code { margin: 0px; } + +div.header p.title { + border: 1px solid black; + font-size: 32px; + font-style: bold; + background-color: LightBlue; + text-align: center; + margin: 0px; + padding: 10px; + font-weight: bold; +} + +div.links { + background-color: Azure; + margin-top: 2px; + padding: 8px 4px 8px 4px; + border: solid 1px; +} + +div.content { + margin-top: 2px; + padding: 8px; + border: solid 1px; +} + +div.content p.title { + font-size: 28px; + text-align: left; + margin: 0px; + margin-bottom: 8px; + padding: 12px; + font-weight: bold; +} + +table { border-collapse: collapse; } +td, th { text-align: center; } + +table.list td, th { padding: 3px 8px 2px 8px; border:1px solid black; } +table.list td { font-family: monospace; } +table.list th { background-color: LightGray; } + +table.attributes td { text-align: left; } +table.attributes > tbody > tr > td:first-child { font-family: sans-serif; } + +table.raw { border-style: none; } +table.raw td { + padding: 0em 0.5em 0em 0.5em; + border-style: none; + vertical-align: top; + text-align: right; + font-family: monospace; +} +table.raw > tbody > tr > td:first-child { border-left: 0px; } +table.raw > tbody > tr > td { border-left: 1px solid; } + +a.button { + background-color: PeachPuff; + text-decoration: underline; + text-align: center; + color: Black; + padding: 4px; + border: solid 1px; +} + +a.small { + padding: 2px 4px 2px 4px; + font-size: small; + border-color: Gray; + background-color: PapayaWhip; +} + +a.button:hover { background-color: LightYellow; } +a.button:active { background-color: Yellow; } + +a.column { + border-style: none; + display: block; + margin: -3px -8px -2px -8px; +} + +div.warning { + background-color: MistyRose; + border: 1px solid Crimson; + padding: 0.5em; + font-size: x-large; +} diff --git a/deprecated/automation/server/monitor/templates/base.html b/deprecated/automation/server/monitor/templates/base.html new file mode 100644 index 00000000..95ffc222 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/base.html @@ -0,0 +1,30 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" +"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> + <head> + <link rel="stylesheet" href="/static/style.css" /> + <title>{% block title %}Automation Dashboard{% endblock %}</title> + </head> + + <body> + <div class="header"> + {% block header %} + <p class="title">Automation Dashboard</p> + {% endblock %} + </div> + + <div class="links"> + <span>Subpages:</span> + {% block links %} + {% for link in links %} + <a class="button" href="{{ link.href }}">{{ link.name }}</a> + {% endfor %} + {% endblock %} + </div> + + <div class="content"> + {% block content %} + {% endblock %} + </div> + </body> +</html> diff --git a/deprecated/automation/server/monitor/templates/job.html b/deprecated/automation/server/monitor/templates/job.html new file mode 100644 index 00000000..90acd969 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/job.html @@ -0,0 +1,29 @@ +{% extends "base.html" %} + +{% block content %} +<h1 class="title">Job {{ job_id }}</h1> + +<h2 class="title">General information</h2> +{% include "snippet_attribute_table.html" %} + +<h2 class="title">Timeline of status events</h2> +<table class="list"> + <tbody> + <tr> + <th>Started</th> + <th>From State</th> + <th>To State</th> + <th>Elapsed</th> + </tr> + {% for entry in timeline %} + <tr> + <td>{{ entry.started }}</td> + <td>{{ entry.state_from }}</td> + <td>{{ entry.state_to }}</td> + <td>{{ entry.elapsed }}</td> + </tr> + {% endfor %} + </tbody> +</table> + +{% endblock %} diff --git a/deprecated/automation/server/monitor/templates/job_group.html b/deprecated/automation/server/monitor/templates/job_group.html new file mode 100644 index 00000000..b6ed8ea8 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/job_group.html @@ -0,0 +1,46 @@ +{% extends "base.html" %} + +{% block content %} +<h1 class="title">Job Group {{ group_id }}</h1> + +<h2 class="title">General information</h2> +{% include "snippet_attribute_table.html" %} + +<h2 class="title">Job Listing</h2> +<table class="list"> + <tbody> + <tr> + <th>Job ID</th> + <th>Label</th> + <th>Turnaround Time</th> + <th>State</th> + </tr> + {% for job in job_list %} + <tr> + <td> + <a class="button column" href="/job/{{ job.id }}">{{ job.id }}</a> + </td> + <td>{{ job.label }}</td> + <td>{{ job.elapsed }}</td> + {% if job.status %} + <td class="{{ job.status }}">{{ job.state }}</td> + {% else %} + <td>{{ job.state }}</td> + {% endif %} + </tr> + {% endfor %} + </tbody> +</table> + +<h2 class="title">Report</h2> +{% if reports %} +{% autoescape off %} +{% for report in reports %} +{{ report }} +{% endfor %} +{% endautoescape %} +{% else %} +<div class="warning">No reports found!</div> +{% endif %} + +{% endblock %} diff --git a/deprecated/automation/server/monitor/templates/job_group_list.html b/deprecated/automation/server/monitor/templates/job_group_list.html new file mode 100644 index 00000000..b82fa730 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/job_group_list.html @@ -0,0 +1,35 @@ +{% extends "base.html" %} + +{% block content %} +<p class="title">Job Groups</p> + +<form action="/job-group" method="post"> +{{ filter.as_p }} +<p><input type="submit" value="Filter!" /></p> +</form> + +<table class="list"> + <tbody> + <tr> + <th>Group ID</th> + <th>Label</th> + <th>Time Submitted</th> + <th>Status</th> + </tr> + {% for group in groups %} + <tr> + <td> + <a class="button column" href="/job-group/{{ group.id }}">{{ group.id }}</a> + </td> + <td>{{ group.label }}</td> + <td>{{ group.submitted }}</td> + {% if group.status %} + <td class="{{ group.status }}">{{ group.state }}</td> + {% else %} + <td>{{ group.state }}</td> + {% endif %} + </tr> + {% endfor %} + </tbody> +</table> +{% endblock %} diff --git a/deprecated/automation/server/monitor/templates/job_log.html b/deprecated/automation/server/monitor/templates/job_log.html new file mode 100644 index 00000000..937b21b0 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/job_log.html @@ -0,0 +1,20 @@ +{% extends "base.html" %} + +{% block content %} +<h1 class="title">Job {{ job_id }}</h1> + +<h2 class="title">Command output:</h2> + +<table class="raw"> +<tbody> +{% for datetime, stream, line in log_lines %} +<tr class="{% cycle 'line1' 'line2' %}"> + <td>{{ datetime }}</td> + <td>{{ stream }}</td> + <td><pre class="code">{{ line|wordwrap:80 }}</pre></td> +</tr> +{% endfor %} +</tbody> +</table> + +{% endblock %} diff --git a/deprecated/automation/server/monitor/templates/machine_list.html b/deprecated/automation/server/monitor/templates/machine_list.html new file mode 100644 index 00000000..f81422d3 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/machine_list.html @@ -0,0 +1,39 @@ +{% extends "base.html" %} + +{% block content %} +<p class="title">Machines</p> + +<table class="list"> +<tbody> +<tr> + <th>Hostname</th> + <th>Label</th> + <th>CPU</th> + <th>Cores</th> + <th>Operating System</th> + <th>Jobs Running</th> + <th>Locked</th> +</tr> +{% for machine in machines %} +<tr> + <td> + <a class="button column" href="/machine/{{ machine.hostname }}"> + {{ machine.hostname }} + </a> + </td> + <td>{{ machine.label }}</td> + <td>{{ machine.cpu }}</td> + <td>{{ machine.cores }}</td> + <td>{{ machine.os }}</td> + <td>{{ machine.uses }}</td> + {% if machine.locked %} + <td class="failure">Yes</td> + {% else %} + <td class="success">No</td> + {% endif %} +</tr> +{% endfor %} +</tbody> +</table> + +{% endblock %} diff --git a/deprecated/automation/server/monitor/templates/snippet_attribute_table.html b/deprecated/automation/server/monitor/templates/snippet_attribute_table.html new file mode 100644 index 00000000..24bacc17 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/snippet_attribute_table.html @@ -0,0 +1,36 @@ +<table class="list attributes"> + <tbody> + <tr> + <th>Attribute</th> + <th>Value</th> + </tr> + {% for name, value in attributes.text %} + <tr> + <td>{{ name }}</td> + <td>{{ value }}</td> + </tr> + {% endfor %} + + {% for name, links in attributes.link %} + <tr> + <td>{{ name }}</td> + <td> + {% if links %} + {% for link in links %} + <a class="button small" href="{{ link.href }}">{{ link.name }}</a> + {% endfor %} + {% else %} + None + {% endif %} + </td> + </tr> + {% endfor %} + + {% for name, code in attributes.code %} + <tr> + <td>{{ name }}</td> + <td>{% include "snippet_code.html" %}</td> + </tr> + {% endfor %} + </tbody> +</table> diff --git a/deprecated/automation/server/monitor/templates/snippet_code.html b/deprecated/automation/server/monitor/templates/snippet_code.html new file mode 100644 index 00000000..281754d6 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/snippet_code.html @@ -0,0 +1,10 @@ +<table class="raw"> +<tbody> +{% for num, line in code %} +<tr class="{% cycle 'line1' 'line2' %}"> + <td>{{ num }}</td> + <td><pre class="code">{{ line|wordwrap:120 }}</pre></td> +</tr> +{% endfor %} +</tbody> +</table> diff --git a/deprecated/automation/server/monitor/templates/snippet_links.html b/deprecated/automation/server/monitor/templates/snippet_links.html new file mode 100644 index 00000000..f19fa6e5 --- /dev/null +++ b/deprecated/automation/server/monitor/templates/snippet_links.html @@ -0,0 +1,7 @@ +{% if param %} +{% for link in param %} +<a class="button small" href="{{ link.href }}">{{ link.name }}</a> +{% endfor %} +{% else %} +None +{% endif %} diff --git a/deprecated/automation/server/monitor/urls.py b/deprecated/automation/server/monitor/urls.py new file mode 100644 index 00000000..1a6b2485 --- /dev/null +++ b/deprecated/automation/server/monitor/urls.py @@ -0,0 +1,21 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +# + +__author__ = 'kbaclawski@google.com (Krystian Baclawski)' + +from django.conf import settings +from django.conf.urls.defaults import patterns + +urlpatterns = patterns( + 'dashboard', (r'^job-group$', 'JobGroupListPageHandler'), + (r'^machine$', 'MachineListPageHandler'), + (r'^job/(?P<job_id>\d+)/log$', 'LogPageHandler'), + (r'^job/(?P<job_id>\d+)$', 'JobPageHandler'), ( + r'^job-group/(?P<job_group_id>\d+)/files/(?P<path>.*)$', + 'JobGroupFilesPageHandler'), + (r'^job-group/(?P<job_group_id>\d+)$', 'JobGroupPageHandler'), + (r'^$', 'DefaultPageHandler')) + +urlpatterns += patterns('', + (r'^static/(?P<path>.*)$', 'django.views.static.serve', + {'document_root': settings.MEDIA_ROOT})) diff --git a/deprecated/automation/server/server.py b/deprecated/automation/server/server.py new file mode 100755 index 00000000..c8f22521 --- /dev/null +++ b/deprecated/automation/server/server.py @@ -0,0 +1,125 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +import logging +import optparse +import pickle +import signal +from SimpleXMLRPCServer import SimpleXMLRPCServer +import sys + +from automation.common import logger +from automation.common.command_executer import CommandExecuter +from automation.server import machine_manager +from automation.server.job_group_manager import JobGroupManager +from automation.server.job_manager import JobManager + + +class Server(object): + """Plays a role of external interface accessible over XMLRPC.""" + + def __init__(self, machines_file=None, dry_run=False): + """Default constructor. + + Args: + machines_file: Path to file storing a list of machines. + dry_run: If True, the server only simulates command execution. + """ + CommandExecuter.Configure(dry_run) + + self.job_manager = JobManager( + machine_manager.MachineManager.FromMachineListFile( + machines_file or machine_manager.DEFAULT_MACHINES_FILE)) + + self.job_group_manager = JobGroupManager(self.job_manager) + + self._logger = logging.getLogger(self.__class__.__name__) + + def ExecuteJobGroup(self, job_group, dry_run=False): + job_group = pickle.loads(job_group) + self._logger.info('Received ExecuteJobGroup(%r, dry_run=%s) request.', + job_group, dry_run) + + for job in job_group.jobs: + job.dry_run = dry_run + return self.job_group_manager.AddJobGroup(job_group) + + def GetAllJobGroups(self): + self._logger.info('Received GetAllJobGroups() request.') + return pickle.dumps(self.job_group_manager.GetAllJobGroups()) + + def KillJobGroup(self, job_group_id): + self._logger.info('Received KillJobGroup(%d) request.', job_group_id) + self.job_group_manager.KillJobGroup(pickle.loads(job_group_id)) + + def GetJobGroup(self, job_group_id): + self._logger.info('Received GetJobGroup(%d) request.', job_group_id) + + return pickle.dumps(self.job_group_manager.GetJobGroup(job_group_id)) + + def GetJob(self, job_id): + self._logger.info('Received GetJob(%d) request.', job_id) + + return pickle.dumps(self.job_manager.GetJob(job_id)) + + def GetMachineList(self): + self._logger.info('Received GetMachineList() request.') + + return pickle.dumps(self.job_manager.machine_manager.GetMachineList()) + + def StartServer(self): + self.job_manager.StartJobManager() + + def StopServer(self): + self.job_manager.StopJobManager() + self.job_manager.join() + + +def GetServerOptions(): + """Get server's settings from command line options.""" + parser = optparse.OptionParser() + parser.add_option('-m', + '--machines-file', + dest='machines_file', + help='The location of the file ' + 'containing the machines database', + default=machine_manager.DEFAULT_MACHINES_FILE) + parser.add_option('-n', + '--dry-run', + dest='dry_run', + help='Start the server in dry-run mode, where jobs will ' + 'not actually be executed.', + action='store_true', + default=False) + return parser.parse_args()[0] + + +def Main(): + logger.SetUpRootLogger(filename='server.log', level=logging.DEBUG) + + options = GetServerOptions() + server = Server(options.machines_file, options.dry_run) + server.StartServer() + + def _HandleKeyboardInterrupt(*_): + server.StopServer() + sys.exit(1) + + signal.signal(signal.SIGINT, _HandleKeyboardInterrupt) + + try: + xmlserver = SimpleXMLRPCServer( + ('localhost', 8000), + allow_none=True, + logRequests=False) + xmlserver.register_instance(server) + xmlserver.serve_forever() + except Exception as ex: + logging.error(ex) + server.StopServer() + sys.exit(1) + + +if __name__ == '__main__': + Main() diff --git a/deprecated/automation/server/server_test.py b/deprecated/automation/server/server_test.py new file mode 100755 index 00000000..131ebb3b --- /dev/null +++ b/deprecated/automation/server/server_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Machine manager unittest. + +MachineManagerTest tests MachineManager. +""" + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import server +import unittest + + +class ServerTest(unittest.TestCase): + + def setUp(self): + pass + + def testGetAllJobs(self): + s = server.Server() + print s.GetAllJobs() + + +if __name__ == '__main__': + unittest.main() diff --git a/deprecated/automation/server/test_pool.csv b/deprecated/automation/server/test_pool.csv new file mode 100644 index 00000000..b0700c9b --- /dev/null +++ b/deprecated/automation/server/test_pool.csv @@ -0,0 +1,4 @@ +hostname,label,cpu,cores,os,username +"chrotomation.mtv.corp.google.com","pc-workstation","core2duo",8,"linux","mobiletc-prebuild" +"chromeos-test1.mtv.corp.google.com","cr48","atom",1,"chromeos","chromeos" +"chromeos-test2.mtv.corp.google.com","cr48","atom",1,"chromeos","chromeos" diff --git a/deprecated/build-binutils/opts.sh b/deprecated/build-binutils/opts.sh new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/deprecated/build-binutils/opts.sh diff --git a/deprecated/build-gcc/opts.sh b/deprecated/build-gcc/opts.sh new file mode 100644 index 00000000..d1e6fadb --- /dev/null +++ b/deprecated/build-gcc/opts.sh @@ -0,0 +1,40 @@ +get_gcc_configure_options() +{ + local CTARGET=$1; shift + local confgcc=$(get_gcc_common_options) + case ${CTARGET} in + arm*) #264534 + local arm_arch="${CTARGET%%-*}" + # Only do this if arm_arch is armv* + if [[ ${arm_arch} == armv* ]] ; then + # Convert armv7{a,r,m} to armv7-{a,r,m} + [[ ${arm_arch} == armv7? ]] && arm_arch=${arm_arch/7/7-} + # Remove endian ('l' / 'eb') + [[ ${arm_arch} == *l ]] && arm_arch=${arm_arch%l} + [[ ${arm_arch} == *eb ]] && arm_arch=${arm_arch%eb} + confgcc="${confgcc} --with-arch=${arm_arch}" + confgcc="${confgcc} --disable-esp" + fi + ;; + i?86*) + # Hardened is enabled for x86, but disabled for ARM. + confgcc="${confgcc} --with-arch=atom" + confgcc="${confgcc} --enable-esp" + ;; + esac + echo ${confgcc} +} + +get_gcc_common_options() +{ + local confgcc + # TODO(asharif): Build without these options. + confgcc="${confgcc} --disable-libmudflap" + confgcc="${confgcc} --disable-libssp" + confgcc="${confgcc} --disable-libgomp" + confgcc="${confgcc} --enable-__cxa_atexit" + confgcc="${confgcc} --enable-checking=release" + confgcc="${confgcc} --disable-libquadmath" + echo ${confgcc} +} + diff --git a/deprecated/build_chrome_browser.py b/deprecated/build_chrome_browser.py new file mode 100755 index 00000000..c3b78870 --- /dev/null +++ b/deprecated/build_chrome_browser.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Script to checkout the ChromeOS source. + +This script sets up the ChromeOS source in the given directory, matching a +particular release of ChromeOS. +""" + +from __future__ import print_function + +__author__ = 'raymes@google.com (Raymes Khoury)' + +import argparse +import os +import sys + +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import misc + + +def Usage(parser, message): + print('ERROR: %s' % message) + parser.print_help() + sys.exit(0) + + +def Main(argv): + """Build Chrome browser.""" + + cmd_executer = command_executer.GetCommandExecuter() + + parser = argparse.ArgumentParser() + parser.add_argument( + '--chromeos_root', + dest='chromeos_root', + help='Target directory for ChromeOS installation.') + parser.add_argument('--version', dest='version') + parser.add_argument( + '--clean', + dest='clean', + default=False, + action='store_true', + help=('Clean the /var/cache/chromeos-chrome/' + 'chrome-src/src/out_$board dir')) + parser.add_argument( + '--env', dest='env', default='', help='Use the following env') + parser.add_argument( + '--ebuild_version', + dest='ebuild_version', + help='Use this ebuild instead of the default one.') + parser.add_argument( + '--cflags', + dest='cflags', + default='', + help='CFLAGS for the ChromeOS packages') + parser.add_argument( + '--cxxflags', + dest='cxxflags', + default='', + help='CXXFLAGS for the ChromeOS packages') + parser.add_argument( + '--ldflags', + dest='ldflags', + default='', + help='LDFLAGS for the ChromeOS packages') + parser.add_argument( + '--board', dest='board', help='ChromeOS target board, e.g. x86-generic') + parser.add_argument( + '--no_build_image', + dest='no_build_image', + default=False, + action='store_true', + help=('Skip build image after building browser.' + 'Defaults to False.')) + parser.add_argument( + '--label', + dest='label', + help='Optional label to apply to the ChromeOS image.') + parser.add_argument( + '--build_image_args', + default='', + dest='build_image_args', + help='Optional arguments to build_image.') + parser.add_argument( + '--cros_workon', + dest='cros_workon', + help='Build using external source tree.') + parser.add_argument( + '--dev', + dest='dev', + default=False, + action='store_true', + help=('Build a dev (eg. writable/large) image. ' + 'Defaults to False.')) + parser.add_argument( + '--debug', + dest='debug', + default=False, + action='store_true', + help=('Build chrome browser using debug mode. ' + 'This option implies --dev. Defaults to false.')) + parser.add_argument( + '--verbose', + dest='verbose', + default=False, + action='store_true', + help='Build with verbose information.') + + options = parser.parse_args(argv) + + if options.chromeos_root is None: + Usage(parser, '--chromeos_root must be set') + + if options.board is None: + Usage(parser, '--board must be set') + + if options.version is None: + logger.GetLogger().LogOutput('No Chrome version given so ' + 'using the default checked in version.') + chrome_version = '' + else: + chrome_version = 'CHROME_VERSION=%s' % options.version + + if options.dev and options.no_build_image: + logger.GetLogger().LogOutput( + "\"--dev\" is meaningless if \"--no_build_image\" is given.") + + if options.debug: + options.dev = True + + options.chromeos_root = misc.CanonicalizePath(options.chromeos_root) + + unmask_env = 'ACCEPT_KEYWORDS=~*' + if options.ebuild_version: + ebuild_version = '=%s' % options.ebuild_version + options.env = '%s %s' % (options.env, unmask_env) + else: + ebuild_version = 'chromeos-chrome' + + if options.cros_workon and not ( + os.path.isdir(options.cros_workon) and os.path.exists( + os.path.join(options.cros_workon, 'src/chromeos/BUILD.gn'))): + Usage(parser, '--cros_workon must be a valid chromium browser checkout.') + + if options.verbose: + options.env = misc.MergeEnvStringWithDict( + options.env, {'USE': 'chrome_internal verbose'}) + else: + options.env = misc.MergeEnvStringWithDict(options.env, + {'USE': 'chrome_internal'}) + if options.debug: + options.env = misc.MergeEnvStringWithDict(options.env, + {'BUILDTYPE': 'Debug'}) + + if options.clean: + misc.RemoveChromeBrowserObjectFiles(options.chromeos_root, options.board) + + chrome_origin = 'SERVER_SOURCE' + if options.cros_workon: + chrome_origin = 'LOCAL_SOURCE' + command = 'cros_workon --board={0} start chromeos-chrome'.format( + options.board) + ret = cmd_executer.ChrootRunCommandWOutput(options.chromeos_root, command) + + # cros_workon start returns non-zero if chromeos-chrome is already a + # cros_workon package. + if ret[0] and ret[2].find( + 'WARNING : Already working on chromeos-base/chromeos-chrome') == -1: + logger.GetLogger().LogFatal('cros_workon chromeos-chrome failed.') + + # Return value is non-zero means we do find the "Already working on..." + # message, keep the information, so later on we do not revert the + # cros_workon status. + cros_workon_keep = (ret[0] != 0) + + # Emerge the browser + emerge_browser_command = ('CHROME_ORIGIN={0} {1} ' + 'CFLAGS="$(portageq-{2} envvar CFLAGS) {3}" ' + 'LDFLAGS="$(portageq-{2} envvar LDFLAGS) {4}" ' + 'CXXFLAGS="$(portageq-{2} envvar CXXFLAGS) {5}" ' + '{6} emerge-{2} --buildpkg {7}').format( + chrome_origin, chrome_version, options.board, + options.cflags, options.ldflags, + options.cxxflags, options.env, ebuild_version) + + cros_sdk_options = '' + if options.cros_workon: + cros_sdk_options = '--chrome_root={0}'.format(options.cros_workon) + + ret = cmd_executer.ChrootRunCommand( + options.chromeos_root, + emerge_browser_command, + cros_sdk_options=cros_sdk_options) + + logger.GetLogger().LogFatalIf(ret, 'build_packages failed') + + if options.cros_workon and not cros_workon_keep: + command = 'cros_workon --board={0} stop chromeos-chrome'.format( + options.board) + ret = cmd_executer.ChrootRunCommand(options.chromeos_root, command) + # cros_workon failed, not a fatal one, just report it. + if ret: + print('cros_workon stop chromeos-chrome failed.') + + if options.no_build_image: + return ret + + # Finally build the image + ret = cmd_executer.ChrootRunCommand(options.chromeos_root, + '{0} {1} {2} {3}'.format( + unmask_env, options.env, + misc.GetBuildImageCommand( + options.board, dev=options.dev), + options.build_image_args)) + + logger.GetLogger().LogFatalIf(ret, 'build_image failed') + + flags_file_name = 'chrome_flags.txt' + flags_file_path = '{0}/src/build/images/{1}/latest/{2}'.format( + options.chromeos_root, options.board, flags_file_name) + flags_file = open(flags_file_path, 'wb') + flags_file.write('CFLAGS={0}\n'.format(options.cflags)) + flags_file.write('CXXFLAGS={0}\n'.format(options.cxxflags)) + flags_file.write('LDFLAGS={0}\n'.format(options.ldflags)) + flags_file.close() + + if options.label: + image_dir_path = '{0}/src/build/images/{1}/latest'.format( + options.chromeos_root, options.board) + real_image_dir_path = os.path.realpath(image_dir_path) + command = 'ln -sf -T {0} {1}/{2}'.format( + os.path.basename(real_image_dir_path),\ + os.path.dirname(real_image_dir_path),\ + options.label) + + ret = cmd_executer.RunCommand(command) + logger.GetLogger().LogFatalIf( + ret, 'Failed to apply symlink label %s' % options.label) + + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/build_tool.py b/deprecated/build_tool.py new file mode 100755 index 00000000..0c2fff65 --- /dev/null +++ b/deprecated/build_tool.py @@ -0,0 +1,849 @@ +#!/usr/bin/env python2 +"""Script to bootstrap the chroot using new toolchain. + +This script allows you to build/install a customized version of gcc/binutils, +either by specifying branch or a local directory. + +This script must be executed outside chroot. + +Below is some typical usage - + +## Build gcc located at /local/gcc/dir and do a bootstrap using the new +## compiler for the chromeos root. The script tries to find a valid chromeos +## tree all the way up from your current working directory. +./build_tool.py --gcc_dir=/loca/gcc/dir --bootstrap + +## Build binutils, using remote branch "mobile_toolchain_v17" and do a +## bootstrap using the new binutils for the chromeos root. The script tries to +## find a valid chromeos tree all the way up from your current working +## directory. +./build_tool.py --binutils_branch=cros/mobile_toolchain_v17 \ + --chromeos_root=/chromeos/dir --bootstrap + +## Same as above except only do it for board daisy - no bootstrapping involved. +./build_tool.py --binutils_branch=cros/mobile_toolchain_v16 \ + --chromeos_root=/chromeos/dir --board=daisy +""" + +from __future__ import print_function + +__author__ = 'shenhan@google.com (Han Shen)' + +import argparse +import os +import re +import sys + +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import misc +import repo_to_repo + +REPO_PATH_PATTERN = 'src/third_party/{0}' +TEMP_BRANCH_NAME = 'internal_testing_branch_no_use' +CHROMIUMOS_OVERLAY_PATH = 'src/third_party/chromiumos-overlay' +EBUILD_PATH_PATTERN = 'src/third_party/chromiumos-overlay/sys-devel/{0}' + + +class Bootstrapper(object): + """Class that handles bootstrap process.""" + + def __init__(self, + chromeos_root, + ndk_dir, + gcc_branch=None, + gcc_dir=None, + binutils_branch=None, + binutils_dir=None, + board=None, + disable_2nd_bootstrap=False, + setup_tool_ebuild_file_only=False): + self._chromeos_root = chromeos_root + self._ndk_dir = ndk_dir + + self._gcc_branch = gcc_branch + self._gcc_branch_tree = None + self._gcc_dir = gcc_dir + self._gcc_ebuild_file = None + self._gcc_ebuild_file_name = None + + self._binutils_branch = binutils_branch + self._binutils_branch_tree = None + self._binutils_dir = binutils_dir + self._binutils_ebuild_file = None + self._binutils_ebuild_file_name = None + + self._setup_tool_ebuild_file_only = setup_tool_ebuild_file_only + + self._ce = command_executer.GetCommandExecuter() + self._logger = logger.GetLogger() + self._board = board + self._disable_2nd_bootstrap = disable_2nd_bootstrap + + def IsTreeSame(self, t1, t2): + diff = 'diff -qr -x .git -x .svn "{0}" "{1}"'.format(t1, t2) + if self._ce.RunCommand(diff, print_to_console=False) == 0: + self._logger.LogOutput('"{0}" and "{1}" are the same."'.format(t1, t2)) + return True + self._logger.LogWarning('"{0}" and "{1}" are different."'.format(t1, t2)) + return False + + def SubmitToLocalBranch(self): + """Copy source code to the chromium source tree and submit it locally.""" + if self._gcc_dir: + if not self.SubmitToolToLocalBranch( + tool_name='gcc', tool_dir=self._gcc_dir): + return False + self._gcc_branch = TEMP_BRANCH_NAME + + if self._binutils_dir: + if not self.SubmitToolToLocalBranch( + tool_name='binutils', tool_dir=self._binutils_dir): + return False + self._binutils_branch = TEMP_BRANCH_NAME + + return True + + def SubmitToolToLocalBranch(self, tool_name, tool_dir): + """Copy the source code to local chromium source tree. + + Args: + tool_name: either 'gcc' or 'binutils' + tool_dir: the tool source dir to be used + + Returns: + True if all succeeded False otherwise. + """ + + # The next few steps creates an internal branch to sync with the tool dir + # user provided. + chrome_tool_dir = self.GetChromeOsToolDir(tool_name) + + # 0. Test to see if git tree is free of local changes. + if not misc.IsGitTreeClean(chrome_tool_dir): + self._logger.LogError( + 'Git repository "{0}" not clean, aborted.'.format(chrome_tool_dir)) + return False + + # 1. Checkout/create a (new) branch for testing. + command = 'cd "{0}" && git checkout -B {1}'.format(chrome_tool_dir, + TEMP_BRANCH_NAME) + ret = self._ce.RunCommand(command) + if ret: + self._logger.LogError('Failed to create a temp branch for test, aborted.') + return False + + if self.IsTreeSame(tool_dir, chrome_tool_dir): + self._logger.LogOutput('"{0}" and "{1}" are the same, sync skipped.'. + format(tool_dir, chrome_tool_dir)) + return True + + # 2. Sync sources from user provided tool dir to chromiumos tool git. + local_tool_repo = repo_to_repo.FileRepo(tool_dir) + chrome_tool_repo = repo_to_repo.GitRepo(chrome_tool_dir, TEMP_BRANCH_NAME) + chrome_tool_repo.SetRoot(chrome_tool_dir) + # Delete all stuff except '.git' before start mapping. + self._ce.RunCommand( + 'cd {0} && find . -maxdepth 1 -not -name ".git" -not -name "." ' + r'\( -type f -exec rm {{}} \; -o ' + r' -type d -exec rm -fr {{}} \; \)'.format(chrome_tool_dir)) + local_tool_repo.MapSources(chrome_tool_repo.GetRoot()) + + # 3. Ensure after sync tree is the same. + if self.IsTreeSame(tool_dir, chrome_tool_dir): + self._logger.LogOutput('Sync successfully done.') + else: + self._logger.LogError('Sync not successful, aborted.') + return False + + # 4. Commit all changes. + # 4.1 Try to get some information about the tool dir we are using. + cmd = 'cd {0} && git log -1 --pretty=oneline'.format(tool_dir) + tool_dir_extra_info = None + ret, tool_dir_extra_info, _ = self._ce.RunCommandWOutput( + cmd, print_to_console=False) + commit_message = 'Synced with tool source tree at - "{0}".'.format(tool_dir) + if not ret: + commit_message += '\nGit log for {0}:\n{1}'.format( + tool_dir, tool_dir_extra_info.strip()) + + if chrome_tool_repo.CommitLocally(commit_message): + self._logger.LogError('Commit to local branch "{0}" failed, aborted.'. + format(TEMP_BRANCH_NAME)) + return False + return True + + def CheckoutBranch(self): + """Checkout working branch for the tools. + + Returns: + True: if operation succeeds. + """ + + if self._gcc_branch: + rv = self.CheckoutToolBranch('gcc', self._gcc_branch) + if rv: + self._gcc_branch_tree = rv + else: + return False + + if self._binutils_branch: + rv = self.CheckoutToolBranch('binutils', self._binutils_branch) + if rv: + self._binutils_branch_tree = rv + else: + return False + + return True + + def CheckoutToolBranch(self, tool_name, tool_branch): + """Checkout the tool branch for a certain tool. + + Args: + tool_name: either 'gcc' or 'binutils' + tool_branch: tool branch to use + + Returns: + True: if operation succeeds. Otherwise False. + """ + + chrome_tool_dir = self.GetChromeOsToolDir(tool_name) + command = 'cd "{0}" && git checkout {1}'.format(chrome_tool_dir, + tool_branch) + if not self._ce.RunCommand(command, print_to_console=True): + # Get 'TREE' value of this commit + command = ('cd "{0}" && git cat-file -p {1} ' + '| grep -E "^tree [a-f0-9]+$" ' + '| cut -d" " -f2').format(chrome_tool_dir, tool_branch) + ret, stdout, _ = self._ce.RunCommandWOutput( + command, print_to_console=False) + # Pipe operation always has a zero return value. So need to check if + # stdout is valid. + if not ret and stdout and re.match('[0-9a-h]{40}', + stdout.strip(), re.IGNORECASE): + tool_branch_tree = stdout.strip() + self._logger.LogOutput('Find tree for {0} branch "{1}" - "{2}"'.format( + tool_name, tool_branch, tool_branch_tree)) + return tool_branch_tree + self._logger.LogError(('Failed to checkout "{0}" or failed to ' + 'get tree value, aborted.').format(tool_branch)) + return None + + def FindEbuildFile(self): + """Find the ebuild files for the tools. + + Returns: + True: if operation succeeds. + """ + + if self._gcc_branch: + (rv, ef, efn) = self.FindToolEbuildFile('gcc') + if rv: + self._gcc_ebuild_file = ef + self._gcc_ebuild_file_name = efn + else: + return False + + if self._binutils_branch: + (rv, ef, efn) = self.FindToolEbuildFile('binutils') + if rv: + self._binutils_ebuild_file = ef + self._binutils_ebuild_file_name = efn + else: + return False + + return True + + def FindToolEbuildFile(self, tool_name): + """Find ebuild file for a specific tool. + + Args: + tool_name: either "gcc" or "binutils". + + Returns: + A triplet that consisits of whether operation succeeds or not, + tool ebuild file full path and tool ebuild file name. + """ + + # To get the active gcc ebuild file, we need a workable chroot first. + if not os.path.exists( + os.path.join(self._chromeos_root, 'chroot')) and self._ce.RunCommand( + 'cd "{0}" && cros_sdk --create'.format(self._chromeos_root)): + self._logger.LogError(('Failed to install a initial chroot, aborted.\n' + 'If previous bootstrap failed, do a ' + '"cros_sdk --delete" to remove ' + 'in-complete chroot.')) + return (False, None, None) + + rv, stdout, _ = self._ce.ChrootRunCommandWOutput( + self._chromeos_root, + 'equery w sys-devel/{0}'.format(tool_name), + print_to_console=True) + if rv: + self._logger.LogError( + ('Failed to execute inside chroot ' + '"equery w sys-devel/{0}", aborted.').format(tool_name)) + return (False, None, None) + m = re.match(r'^.*/({0}/(.*\.ebuild))$'.format( + EBUILD_PATH_PATTERN.format(tool_name)), stdout) + if not m: + self._logger.LogError( + ('Failed to find {0} ebuild file, aborted. ' + 'If previous bootstrap failed, do a "cros_sdk --delete" to remove ' + 'in-complete chroot.').format(tool_name)) + return (False, None, None) + tool_ebuild_file = os.path.join(self._chromeos_root, m.group(1)) + tool_ebuild_file_name = m.group(2) + + return (True, tool_ebuild_file, tool_ebuild_file_name) + + def InplaceModifyEbuildFile(self): + """Modify the ebuild file. + + Returns: + True if operation succeeds. + """ + + # Note we shall not use remote branch name (eg. "cros/gcc.gnu.org/...") in + # CROS_WORKON_COMMIT, we have to use GITHASH. So we call GitGetCommitHash on + # tool_branch. + tool = None + toolbranch = None + if self._gcc_branch: + tool = 'gcc' + toolbranch = self._gcc_branch + tooltree = self._gcc_branch_tree + toolebuild = self._gcc_ebuild_file + elif self._binutils_branch: + tool = 'binutils' + toolbranch = self._binutils_branch + tooltree = self._binutils_branch_tree + toolebuild = self._binutils_ebuild_file + + assert tool + + # An example for the following variables would be: + # tooldir = '~/android/master-ndk/toolchain/gcc/gcc-4.9' + # tool_branch_githash = xxxxx + # toolcomponents = toolchain/gcc + tooldir = self.GetChromeOsToolDir(tool) + toolgithash = misc.GitGetCommitHash(tooldir, toolbranch) + if not toolgithash: + return False + toolcomponents = 'toolchain/{}'.format(tool) + return self.InplaceModifyToolEbuildFile(toolcomponents, toolgithash, + tooltree, toolebuild) + + @staticmethod + def ResetToolEbuildFile(chromeos_root, tool_name): + """Reset tool ebuild file to clean state. + + Args: + chromeos_root: chromeos source tree + tool_name: either "gcc" or "binutils" + + Returns: + True if operation succeds. + """ + rv = misc.GetGitChangesAsList( + os.path.join(chromeos_root, CHROMIUMOS_OVERLAY_PATH), + path=('sys-devel/{0}/{0}-*.ebuild'.format(tool_name)), + staged=False) + if rv: + cmd = 'cd {0} && git checkout --'.format( + os.path.join(chromeos_root, CHROMIUMOS_OVERLAY_PATH)) + for g in rv: + cmd += ' ' + g + rv = command_executer.GetCommandExecuter().RunCommand(cmd) + if rv: + logger.GetLogger().LogWarning( + 'Failed to reset the ebuild file. Please refer to log above.') + return False + else: + logger.GetLogger().LogWarning( + 'Note - did not find any modified {0} ebuild file.'.format(tool_name)) + # Fall through + return True + + def GetChromeOsToolDir(self, tool_name): + """Return the chromeos git dir for a specific tool. + + Note, after we unified ChromeOs and Android, the tool dir is under + ndk_dir/toolchain/[gcc,binutils]. + + Args: + tool_name: either 'gcc' or 'binutils'. + + Returns: + Absolute git path for the tool. + """ + + tool_toppath = os.path.join(self._ndk_dir, 'toolchain', tool_name) + # There may be sub-directories like 'binutils-2.25', 'binutils-2.24', + # 'gcc-4.9', 'gcc-4.8', etc. find the newest binutils version. + cmd = ('find {} -maxdepth 1 -type d -name "{}-*" ' + '| sort -r | head -1').format(tool_toppath, tool_name) + rv, out, _ = self._ce.RunCommandWOutput(cmd, print_to_console=False) + if rv: + return None + repo = out.strip() + + # cros-workon eclass expects every CROS_WORKON_PROJECT ends with ".git". + self._ce.RunCommand(('cd $(dirname {0}) && ' + 'ln -sf $(basename {0}) $(basename {0}).git').format( + repo, print_to_console=True)) + return repo + + def InplaceModifyToolEbuildFile(self, tool_components, tool_branch_githash, + tool_branch_tree, tool_ebuild_file): + """Using sed to fill properly values into the ebuild file. + + Args: + tool_components: either "toolchain/gcc" or "toolchain/binutils" + tool_branch_githash: githash for tool_branch + tool_branch_tree: treeish for the tool branch + tool_ebuild_file: tool ebuild file + + Returns: + True: if operation succeeded. + """ + + command = ('sed -i ' + '-e \'/^CROS_WORKON_REPO=".*"/i' + ' # The following line is modified by script.\' ' + '-e \'s!^CROS_WORKON_REPO=".*"$!CROS_WORKON_REPO="{0}"!\' ' + '-e \'/^CROS_WORKON_PROJECT=".*"/i' + ' # The following line is modified by script.\' ' + '-e \'s!^CROS_WORKON_PROJECT=.*$!CROS_WORKON_PROJECT="{1}"!\' ' + '-e \'/^CROS_WORKON_COMMIT=".*"/i' + ' # The following line is modified by script.\' ' + '-e \'s!^CROS_WORKON_COMMIT=".*"$!CROS_WORKON_COMMIT="{2}"!\' ' + '-e \'/^CROS_WORKON_TREE=".*"/i' + ' # The following line is modified by script.\' ' + '-e \'s!^CROS_WORKON_TREE=".*"$!CROS_WORKON_TREE="{3}"!\' ' + '{4}').format('/home/{}/ndk-root'.format(os.environ['USER']), + tool_components, tool_branch_githash, + tool_branch_tree, tool_ebuild_file) + rv = self._ce.RunCommand(command) + if rv: + self._logger.LogError( + 'Failed to modify commit and tree value for "{0}"", aborted.'.format( + tool_ebuild_file)) + return False + + # Warn that the ebuild file has been modified. + self._logger.LogWarning( + ('Ebuild file "{0}" is modified, to revert the file - \n' + 'bootstrap_compiler.py --chromeos_root={1} ' + '--reset_tool_ebuild_file').format(tool_ebuild_file, + self._chromeos_root)) + return True + + def DoBuildForBoard(self): + """Build tool for a specific board. + + Returns: + True if operation succeeds. + """ + + if self._gcc_branch: + if not self.DoBuildToolForBoard('gcc'): + return False + if self._binutils_branch: + if not self.DoBuildToolForBoard('binutils'): + return False + return True + + def DoBuildToolForBoard(self, tool_name): + """Build a specific tool for a specific board. + + Args: + tool_name: either "gcc" or "binutils" + + Returns: + True if operation succeeds. + """ + + chroot_ndk_root = os.path.join(self._chromeos_root, 'chroot', 'home', + os.environ['USER'], 'ndk-root') + self._ce.RunCommand('mkdir -p {}'.format(chroot_ndk_root)) + if self._ce.RunCommand( + 'sudo mount --bind {} {}'.format(self._ndk_dir, chroot_ndk_root)): + self._logger.LogError('Failed to mount ndk dir into chroot') + return False + + try: + boards_to_build = self._board.split(',') + target_built = set() + failed = [] + for board in boards_to_build: + if board == 'host': + command = 'sudo emerge sys-devel/{0}'.format(tool_name) + else: + target = misc.GetCtargetFromBoard(board, self._chromeos_root) + if not target: + self._logger.LogError( + 'Unsupported board "{0}", skip.'.format(board)) + failed.append(board) + continue + # Skip this board if we have already built for a board that has the + # same target. + if target in target_built: + self._logger.LogWarning( + 'Skipping toolchain for board "{}"'.format(board)) + continue + target_built.add(target) + command = 'sudo emerge cross-{0}/{1}'.format(target, tool_name) + + rv = self._ce.ChrootRunCommand( + self._chromeos_root, command, print_to_console=True) + if rv: + self._logger.LogError( + 'Build {0} failed for {1}, aborted.'.format(tool_name, board)) + failed.append(board) + else: + self._logger.LogOutput( + 'Successfully built {0} for board {1}.'.format(tool_name, board)) + finally: + # Make sure we un-mount ndk-root before we leave here, regardless of the + # build result of the tool. Otherwise we may inadvertently delete ndk-root + # dir, which is not part of the chroot and could be disastrous. + if chroot_ndk_root: + if self._ce.RunCommand('sudo umount {}'.format(chroot_ndk_root)): + self._logger.LogWarning( + ('Failed to umount "{}", please check ' + 'before deleting chroot.').format(chroot_ndk_root)) + + # Clean up soft links created during build. + self._ce.RunCommand('cd {}/toolchain/{} && git clean -df'.format( + self._ndk_dir, tool_name)) + + if failed: + self._logger.LogError( + 'Failed to build {0} for the following board(s): "{1}"'.format( + tool_name, ' '.join(failed))) + return False + # All boards build successfully + return True + + def DoBootstrapping(self): + """Do bootstrapping the chroot. + + This step firstly downloads a prestine sdk, then use this sdk to build the + new sdk, finally use the new sdk to build every host package. + + Returns: + True if operation succeeds. + """ + + logfile = os.path.join(self._chromeos_root, 'bootstrap.log') + command = 'cd "{0}" && cros_sdk --delete --bootstrap |& tee "{1}"'.format( + self._chromeos_root, logfile) + rv = self._ce.RunCommand(command, print_to_console=True) + if rv: + self._logger.LogError( + 'Bootstrapping failed, log file - "{0}"\n'.format(logfile)) + return False + + self._logger.LogOutput('Bootstrap succeeded.') + return True + + def BuildAndInstallAmd64Host(self): + """Build amd64-host (host) packages. + + Build all host packages in the newly-bootstrapped 'chroot' using *NEW* + toolchain. + + So actually we perform 2 builds of all host packages - + 1. build new toolchain using old toolchain and build all host packages + using the newly built toolchain + 2. build the new toolchain again but using new toolchain built in step 1, + and build all host packages using the newly built toolchain + + Returns: + True if operation succeeds. + """ + + cmd = 'cd {0} && cros_sdk -- -- ./build_sdk_board'.format( + self._chromeos_root) + rv = self._ce.RunCommand(cmd, print_to_console=True) + if rv: + self._logger.LogError('Build amd64-host failed.') + return False + + # Package amd64-host into 'built-sdk.tar.xz'. + sdk_package = os.path.join(self._chromeos_root, 'built-sdk.tar.xz') + cmd = ('cd {0}/chroot/build/amd64-host && sudo XZ_OPT="-e9" ' + 'tar --exclude="usr/lib/debug/*" --exclude="packages/*" ' + '--exclude="tmp/*" --exclude="usr/local/build/autotest/*" ' + '--sparse -I xz -vcf {1} . && sudo chmod a+r {1}').format( + self._chromeos_root, sdk_package) + rv = self._ce.RunCommand(cmd, print_to_console=True) + if rv: + self._logger.LogError('Failed to create "built-sdk.tar.xz".') + return False + + # Install amd64-host into a new chroot. + cmd = ('cd {0} && cros_sdk --chroot new-sdk-chroot --download --replace ' + '--nousepkg --url file://{1}').format(self._chromeos_root, + sdk_package) + rv = self._ce.RunCommand(cmd, print_to_console=True) + if rv: + self._logger.LogError('Failed to install "built-sdk.tar.xz".') + return False + self._logger.LogOutput( + 'Successfully installed built-sdk.tar.xz into a new chroot.\nAll done.') + + # Rename the newly created new-sdk-chroot to chroot. + cmd = ('cd {0} && sudo mv chroot chroot-old && ' + 'sudo mv new-sdk-chroot chroot').format(self._chromeos_root) + rv = self._ce.RunCommand(cmd, print_to_console=True) + return rv == 0 + + def Do(self): + """Entrance of the class. + + Returns: + True if everything is ok. + """ + + if (self.SubmitToLocalBranch() and self.CheckoutBranch() and + self.FindEbuildFile() and self.InplaceModifyEbuildFile()): + if self._setup_tool_ebuild_file_only: + # Everything is done, we are good. + ret = True + else: + if self._board: + ret = self.DoBuildForBoard() + else: + # This implies '--bootstrap'. + ret = (self.DoBootstrapping() and (self._disable_2nd_bootstrap or + self.BuildAndInstallAmd64Host())) + else: + ret = False + return ret + + +def Main(argv): + parser = argparse.ArgumentParser() + parser.add_argument( + '-c', + '--chromeos_root', + dest='chromeos_root', + help=('Optional. ChromeOs root dir. ' + 'When not specified, chromeos root will be deduced' + ' from current working directory.')) + parser.add_argument( + '--ndk_dir', + dest='ndk_dir', + help=('Topmost android ndk dir, required. ' + 'Do not need to include the "toolchain/*" part.')) + parser.add_argument( + '--gcc_branch', + dest='gcc_branch', + help=('The branch to test against. ' + 'This branch must be a local branch ' + 'inside "src/third_party/gcc". ' + 'Notice, this must not be used with "--gcc_dir".')) + parser.add_argument( + '--binutils_branch', + dest='binutils_branch', + help=('The branch to test against binutils. ' + 'This branch must be a local branch ' + 'inside "src/third_party/binutils". ' + 'Notice, this must not be used with ' + '"--binutils_dir".')) + parser.add_argument( + '-g', + '--gcc_dir', + dest='gcc_dir', + help=('Use a local gcc tree to do bootstrapping. ' + 'Notice, this must not be used with ' + '"--gcc_branch".')) + parser.add_argument( + '--binutils_dir', + dest='binutils_dir', + help=('Use a local binutils tree to do bootstrapping. ' + 'Notice, this must not be used with ' + '"--binutils_branch".')) + parser.add_argument( + '--fixperm', + dest='fixperm', + default=False, + action='store_true', + help=('Fix the (notorious) permission error ' + 'while trying to bootstrap the chroot. ' + 'Note this takes an extra 10-15 minutes ' + 'and is only needed once per chromiumos tree.')) + parser.add_argument( + '--setup_tool_ebuild_file_only', + dest='setup_tool_ebuild_file_only', + default=False, + action='store_true', + help=('Setup gcc and/or binutils ebuild file ' + 'to pick up the branch (--gcc/binutils_branch) or ' + 'use gcc and/or binutils source ' + '(--gcc/binutils_dir) and exit. Keep chroot as is.' + ' This should not be used with ' + '--gcc/binutils_dir/branch options.')) + parser.add_argument( + '--reset_tool_ebuild_file', + dest='reset_tool_ebuild_file', + default=False, + action='store_true', + help=('Reset the modification that is done by this ' + 'script. Note, when this script is running, it ' + 'will modify the active gcc/binutils ebuild file. ' + 'Use this option to reset (what this script has ' + 'done) and exit. This should not be used with -- ' + 'gcc/binutils_dir/branch options.')) + parser.add_argument( + '--board', + dest='board', + default=None, + help=('Only build toolchain for specific board(s). ' + 'Use "host" to build for host. ' + 'Use "," to seperate multiple boards. ' + 'This does not perform a chroot bootstrap.')) + parser.add_argument( + '--bootstrap', + dest='bootstrap', + default=False, + action='store_true', + help=('Performs a chroot bootstrap. ' + 'Note, this will *destroy* your current chroot.')) + parser.add_argument( + '--disable-2nd-bootstrap', + dest='disable_2nd_bootstrap', + default=False, + action='store_true', + help=('Disable a second bootstrap ' + '(build of amd64-host stage).')) + + options = parser.parse_args(argv) + # Trying to deduce chromeos root from current directory. + if not options.chromeos_root: + logger.GetLogger().LogOutput('Trying to deduce chromeos root ...') + wdir = os.getcwd() + while wdir and wdir != '/': + if misc.IsChromeOsTree(wdir): + logger.GetLogger().LogOutput('Find chromeos_root: {}'.format(wdir)) + options.chromeos_root = wdir + break + wdir = os.path.dirname(wdir) + + if not options.chromeos_root: + parser.error('Missing or failing to deduce mandatory option "--chromeos".') + return 1 + + options.chromeos_root = os.path.abspath( + os.path.expanduser(options.chromeos_root)) + + if not os.path.isdir(options.chromeos_root): + logger.GetLogger().LogError( + '"{0}" does not exist.'.format(options.chromeos_root)) + return 1 + + options.ndk_dir = os.path.expanduser(options.ndk_dir) + if not options.ndk_dir: + parser.error('Missing mandatory option "--ndk_dir".') + return 1 + + # Some tolerance regarding user input. We only need the ndk_root part, do not + # include toolchain/(gcc|binutils)/ part in this option. + options.ndk_dir = re.sub('/toolchain(/gcc|/binutils)?/?$', '', + options.ndk_dir) + + if not (os.path.isdir(options.ndk_dir) and + os.path.isdir(os.path.join(options.ndk_dir, 'toolchain'))): + logger.GetLogger().LogError( + '"toolchain" directory not found under "{0}".'.format(options.ndk_dir)) + return 1 + + if options.fixperm: + # Fix perm error before continuing. + cmd = (r'sudo find "{0}" \( -name ".cache" -type d -prune \) -o ' + r'\( -name "chroot" -type d -prune \) -o ' + r'\( -type f -exec chmod a+r {{}} \; \) -o ' + r'\( -type d -exec chmod a+rx {{}} \; \)' + ).format(options.chromeos_root) + logger.GetLogger().LogOutput( + 'Fixing perm issues for chromeos root, this might take some time.') + command_executer.GetCommandExecuter().RunCommand(cmd) + + if options.reset_tool_ebuild_file: + if (options.gcc_dir or options.gcc_branch or options.binutils_dir or + options.binutils_branch): + logger.GetLogger().LogWarning( + 'Ignoring any "--gcc/binutils_dir" and/or "--gcc/binutils_branch".') + if options.setup_tool_ebuild_file_only: + logger.GetLogger().LogError( + ('Conflict options "--reset_tool_ebuild_file" ' + 'and "--setup_tool_ebuild_file_only".')) + return 1 + rv = Bootstrapper.ResetToolEbuildFile(options.chromeos_root, 'gcc') + rv1 = Bootstrapper.ResetToolEbuildFile(options.chromeos_root, 'binutils') + return 0 if (rv and rv1) else 1 + + if options.gcc_dir: + options.gcc_dir = os.path.abspath(os.path.expanduser(options.gcc_dir)) + if not os.path.isdir(options.gcc_dir): + logger.GetLogger().LogError( + '"{0}" does not exist.'.format(options.gcc_dir)) + return 1 + + if options.gcc_branch and options.gcc_dir: + parser.error('Only one of "--gcc_dir" and "--gcc_branch" can be specified.') + return 1 + + if options.binutils_dir: + options.binutils_dir = os.path.abspath( + os.path.expanduser(options.binutils_dir)) + if not os.path.isdir(options.binutils_dir): + logger.GetLogger().LogError( + '"{0}" does not exist.'.format(options.binutils_dir)) + return 1 + + if options.binutils_branch and options.binutils_dir: + parser.error('Only one of "--binutils_dir" and ' + '"--binutils_branch" can be specified.') + return 1 + + if (not (options.binutils_branch or options.binutils_dir or + options.gcc_branch or options.gcc_dir)): + parser.error(('At least one of "--gcc_dir", "--gcc_branch", ' + '"--binutils_dir" and "--binutils_branch" must ' + 'be specified.')) + return 1 + + if not options.board and not options.bootstrap: + parser.error('You must specify either "--board" or "--bootstrap".') + return 1 + + if (options.board and options.bootstrap and + not options.setup_tool_ebuild_file_only): + parser.error('You must specify only one of "--board" and "--bootstrap".') + return 1 + + if not options.bootstrap and options.disable_2nd_bootstrap: + parser.error('"--disable-2nd-bootstrap" has no effect ' + 'without specifying "--bootstrap".') + return 1 + + if Bootstrapper( + options.chromeos_root, + options.ndk_dir, + gcc_branch=options.gcc_branch, + gcc_dir=options.gcc_dir, + binutils_branch=options.binutils_branch, + binutils_dir=options.binutils_dir, + board=options.board, + disable_2nd_bootstrap=options.disable_2nd_bootstrap, + setup_tool_ebuild_file_only=options.setup_tool_ebuild_file_only).Do(): + return 0 + return 1 + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/crb/autotest_gatherer.py b/deprecated/crb/autotest_gatherer.py new file mode 100644 index 00000000..f8f7b43f --- /dev/null +++ b/deprecated/crb/autotest_gatherer.py @@ -0,0 +1,67 @@ +from table_formatter import TableFormatter as TableFormatter + + +class AutotestGatherer(TableFormatter): + + def __init__(self): + self.runs = [] + TableFormatter.__init__(self) + + def GetFormattedMainTable(self, percents_only, fit_string): + ret = '' + table = self.GetTableValues() + ret += self.GetTableLabels(table) + ret += self.GetFormattedTable(table, + percents_only=percents_only, + fit_string=fit_string) + return ret + + def GetFormattedSummaryTable(self, percents_only, fit_string): + ret = '' + table = self.GetTableValues() + summary_table = self.GetSummaryTableValues(table) + ret += self.GetTableLabels(summary_table) + ret += self.GetFormattedTable(summary_table, + percents_only=percents_only, + fit_string=fit_string) + return ret + + def GetBenchmarksString(self): + ret = 'Benchmarks (in order):' + ret = '\n'.join(self.GetAllBenchmarks()) + return ret + + def GetAllBenchmarks(self): + all_benchmarks = [] + for run in self.runs: + for key in run.results.keys(): + if key not in all_benchmarks: + all_benchmarks.append(key) + all_benchmarks.sort() + return all_benchmarks + + def GetTableValues(self): + table = [] + row = [] + + row.append('Benchmark') + for i in range(len(self.runs)): + run = self.runs[i] + label = run.GetLabel() + label = self.GetLabelWithIteration(label, run.iteration) + row.append(label) + table.append(row) + + all_benchmarks = self.GetAllBenchmarks() + for benchmark in all_benchmarks: + row = [] + row.append(benchmark) + for run in self.runs: + results = run.results + if benchmark in results: + row.append(results[benchmark]) + else: + row.append('') + table.append(row) + + return table diff --git a/deprecated/crb/autotest_run.py b/deprecated/crb/autotest_run.py new file mode 100644 index 00000000..380c578b --- /dev/null +++ b/deprecated/crb/autotest_run.py @@ -0,0 +1,317 @@ +import datetime +import getpass +import glob +import os +import pickle +import re +import threading +import time +import image_chromeos +import machine_manager_singleton +import table_formatter +from cros_utils import command_executer +from cros_utils import logger + +SCRATCH_DIR = '/home/%s/cros_scratch' % getpass.getuser() +PICKLE_FILE = 'pickle.txt' +VERSION = '1' + + +def ConvertToFilename(text): + ret = text + ret = re.sub('/', '__', ret) + ret = re.sub(' ', '_', ret) + ret = re.sub('=', '', ret) + ret = re.sub("\"", '', ret) + return ret + + +class AutotestRun(threading.Thread): + + def __init__(self, + autotest, + chromeos_root='', + chromeos_image='', + board='', + remote='', + iteration=0, + image_checksum='', + exact_remote=False, + rerun=False, + rerun_if_failed=False): + self.autotest = autotest + self.chromeos_root = chromeos_root + self.chromeos_image = chromeos_image + self.board = board + self.remote = remote + self.iteration = iteration + l = logger.GetLogger() + l.LogFatalIf(not image_checksum, "Checksum shouldn't be None") + self.image_checksum = image_checksum + self.results = {} + threading.Thread.__init__(self) + self.terminate = False + self.retval = None + self.status = 'PENDING' + self.run_completed = False + self.exact_remote = exact_remote + self.rerun = rerun + self.rerun_if_failed = rerun_if_failed + self.results_dir = None + self.full_name = None + + @staticmethod + def MeanExcludingSlowest(array): + mean = sum(array) / len(array) + array2 = [] + + for v in array: + if mean != 0 and abs(v - mean) / mean < 0.2: + array2.append(v) + + if array2: + return sum(array2) / len(array2) + else: + return mean + + @staticmethod + def AddComposite(results_dict): + composite_keys = [] + composite_dict = {} + for key in results_dict: + mo = re.match('(.*){\d+}', key) + if mo: + composite_keys.append(mo.group(1)) + for key in results_dict: + for composite_key in composite_keys: + if (key.count(composite_key) != 0 and + table_formatter.IsFloat(results_dict[key])): + if composite_key not in composite_dict: + composite_dict[composite_key] = [] + composite_dict[composite_key].append(float(results_dict[key])) + break + + for composite_key in composite_dict: + v = composite_dict[composite_key] + results_dict['%s[c]' % composite_key] = sum(v) / len(v) + mean_excluding_slowest = AutotestRun.MeanExcludingSlowest(v) + results_dict['%s[ce]' % composite_key] = mean_excluding_slowest + + return results_dict + + def ParseOutput(self): + p = re.compile('^-+.*?^-+', re.DOTALL | re.MULTILINE) + matches = p.findall(self.out) + for i in range(len(matches)): + results = matches[i] + results_dict = {} + for line in results.splitlines()[1:-1]: + mo = re.match('(.*\S)\s+\[\s+(PASSED|FAILED)\s+\]', line) + if mo: + results_dict[mo.group(1)] = mo.group(2) + continue + mo = re.match('(.*\S)\s+(.*)', line) + if mo: + results_dict[mo.group(1)] = mo.group(2) + + # Add a composite keyval for tests like startup. + results_dict = AutotestRun.AddComposite(results_dict) + + self.results = results_dict + + # This causes it to not parse the table again + # Autotest recently added a secondary table + # That reports errors and screws up the final pretty output. + break + mo = re.search('Results placed in (\S+)', self.out) + if mo: + self.results_dir = mo.group(1) + self.full_name = os.path.basename(self.results_dir) + + def GetCacheHashBase(self): + ret = ('%s %s %s' % + (self.image_checksum, self.autotest.name, self.iteration)) + if self.autotest.args: + ret += ' %s' % self.autotest.args + ret += '-%s' % VERSION + return ret + + def GetLabel(self): + ret = '%s %s remote:%s' % (self.chromeos_image, self.autotest.name, + self.remote) + return ret + + def TryToLoadFromCache(self): + base = self.GetCacheHashBase() + if self.exact_remote: + if not self.remote: + return False + cache_dir_glob = '%s_%s' % (ConvertToFilename(base), self.remote) + else: + cache_dir_glob = '%s*' % ConvertToFilename(base) + cache_path_glob = os.path.join(SCRATCH_DIR, cache_dir_glob) + matching_dirs = glob.glob(cache_path_glob) + if matching_dirs: + matching_dir = matching_dirs[0] + cache_file = os.path.join(matching_dir, PICKLE_FILE) + assert os.path.isfile(cache_file) + self._logger.LogOutput('Trying to read from cache file: %s' % cache_file) + return self.ReadFromCache(cache_file) + self._logger.LogOutput('Cache miss. AM going to run: %s for: %s' % + (self.autotest.name, self.chromeos_image)) + return False + + def ReadFromCache(self, cache_file): + with open(cache_file, 'rb') as f: + self.retval = pickle.load(f) + self.out = pickle.load(f) + self.err = pickle.load(f) + self._logger.LogOutput(self.out) + return True + return False + + def StoreToCache(self): + base = self.GetCacheHashBase() + self.cache_dir = os.path.join(SCRATCH_DIR, + '%s_%s' % (ConvertToFilename(base), + self.remote)) + cache_file = os.path.join(self.cache_dir, PICKLE_FILE) + command = 'mkdir -p %s' % os.path.dirname(cache_file) + ret = self._ce.RunCommand(command) + assert ret == 0, "Couldn't create cache dir" + with open(cache_file, 'wb') as f: + pickle.dump(self.retval, f) + pickle.dump(self.out, f) + pickle.dump(self.err, f) + + def run(self): + self._logger = logger.Logger( + os.path.dirname(__file__), '%s.%s' % (os.path.basename(__file__), + self.name), True) + self._ce = command_executer.GetCommandExecuter(self._logger) + self.RunCached() + + def RunCached(self): + self.status = 'WAITING' + cache_hit = False + if not self.rerun: + cache_hit = self.TryToLoadFromCache() + else: + self._logger.LogOutput('--rerun passed. Not using cached results.') + if self.rerun_if_failed and self.retval: + self._logger.LogOutput('--rerun_if_failed passed and existing test ' + 'failed. Rerunning...') + cache_hit = False + if not cache_hit: + # Get machine + while True: + if self.terminate: + return 1 + self.machine = (machine_manager_singleton.MachineManagerSingleton( + ).AcquireMachine(self.image_checksum)) + if self.machine: + self._logger.LogOutput('%s: Machine %s acquired at %s' % + (self.name, self.machine.name, + datetime.datetime.now())) + break + else: + sleep_duration = 10 + time.sleep(sleep_duration) + try: + self.remote = self.machine.name + + if self.machine.checksum != self.image_checksum: + self.retval = self.ImageTo(self.machine.name) + if self.retval: + return self.retval + self.machine.checksum = self.image_checksum + self.machine.image = self.chromeos_image + self.status = 'RUNNING: %s' % self.autotest.name + [self.retval, self.out, self.err] = self.RunTestOn(self.machine.name) + self.run_completed = True + + finally: + self._logger.LogOutput('Releasing machine: %s' % self.machine.name) + machine_manager_singleton.MachineManagerSingleton().ReleaseMachine( + self.machine) + self._logger.LogOutput('Released machine: %s' % self.machine.name) + + self.StoreToCache() + + if not self.retval: + self.status = 'SUCCEEDED' + else: + self.status = 'FAILED' + + self.ParseOutput() + # Copy results directory to the scratch dir + if (not cache_hit and not self.retval and self.autotest.args and + '--profile' in self.autotest.args): + results_dir = os.path.join(self.chromeos_root, 'chroot', + self.results_dir.lstrip('/')) + tarball = os.path.join( + self.cache_dir, os.path.basename(os.path.dirname(self.results_dir))) + command = ('cd %s && tar cjf %s.tbz2 .' % (results_dir, tarball)) + self._ce.RunCommand(command) + perf_data_file = os.path.join(self.results_dir, self.full_name, + 'profiling/iteration.1/perf.data') + + # Attempt to build a perf report and keep it with the results. + command = ('cd %s/src/scripts &&' + ' cros_sdk -- /usr/sbin/perf report --symfs=/build/%s' + ' -i %s --stdio' % (self.chromeos_root, self.board, + perf_data_file)) + ret, out, err = self._ce.RunCommandWOutput(command) + with open(os.path.join(self.cache_dir, 'perf.report'), 'wb') as f: + f.write(out) + return self.retval + + def ImageTo(self, machine_name): + image_args = [image_chromeos.__file__, '--chromeos_root=%s' % + self.chromeos_root, '--image=%s' % self.chromeos_image, + '--remote=%s' % machine_name] + if self.board: + image_args.append('--board=%s' % self.board) + +### devserver_port = 8080 +### mo = re.search("\d+", self.name) +### if mo: +### to_add = int(mo.group(0)) +### assert to_add < 100, "Too many threads launched!" +### devserver_port += to_add + +### # I tried --noupdate_stateful, but that still fails when run in parallel. +### image_args.append("--image_to_live_args=\"--devserver_port=%s" +### " --noupdate_stateful\"" % devserver_port) +### image_args.append("--image_to_live_args=--devserver_port=%s" % +### devserver_port) + +# Currently can't image two machines at once. +# So have to serialized on this lock. + self.status = 'WAITING ON IMAGE_LOCK' + with machine_manager_singleton.MachineManagerSingleton().image_lock: + self.status = 'IMAGING' + retval = self._ce.RunCommand(' '.join(['python'] + image_args)) + machine_manager_singleton.MachineManagerSingleton().num_reimages += 1 + if retval: + self.status = 'ABORTED DUE TO IMAGE FAILURE' + return retval + + def DoPowerdHack(self): + command = 'sudo initctl stop powerd' + self._ce.CrosRunCommand(command, + machine=self.machine.name, + chromeos_root=self.chromeos_root) + + def RunTestOn(self, machine_name): + command = 'cd %s/src/scripts' % self.chromeos_root + options = '' + if self.board: + options += ' --board=%s' % self.board + if self.autotest.args: + options += " --args='%s'" % self.autotest.args + if 'tegra2' in self.board: + self.DoPowerdHack() + command += ('&& cros_sdk -- /usr/bin/test_that %s %s %s' % + (options, machine_name, self.autotest.name)) + return self._ce.RunCommand(command, True) diff --git a/deprecated/crb/crb_driver.py b/deprecated/crb/crb_driver.py new file mode 100755 index 00000000..c6403462 --- /dev/null +++ b/deprecated/crb/crb_driver.py @@ -0,0 +1,370 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +import datetime +import optparse +import os +import smtplib +import sys +import time +from email.mime.text import MIMEText + +from autotest_gatherer import AutotestGatherer as AutotestGatherer +from autotest_run import AutotestRun as AutotestRun +from machine_manager_singleton import MachineManagerSingleton as MachineManagerSingleton +from cros_utils import logger +from cros_utils.file_utils import FileUtils + + +def CanonicalizeChromeOSRoot(chromeos_root): + chromeos_root = os.path.expanduser(chromeos_root) + if os.path.isfile(os.path.join(chromeos_root, 'src/scripts/enter_chroot.sh')): + return chromeos_root + else: + return None + + +class Autotest(object): + + def __init__(self, autotest_string): + self.name = None + self.iterations = None + self.args = None + fields = autotest_string.split(',', 1) + self.name = fields[0] + if len(fields) > 1: + autotest_string = fields[1] + fields = autotest_string.split(',', 1) + else: + return + self.iterations = int(fields[0]) + if len(fields) > 1: + self.args = fields[1] + else: + return + + def __str__(self): + return '\n'.join([self.name, self.iterations, self.args]) + + +def CreateAutotestListFromString(autotest_strings, default_iterations=None): + autotest_list = [] + for autotest_string in autotest_strings.split(':'): + autotest = Autotest(autotest_string) + if default_iterations and not autotest.iterations: + autotest.iterations = default_iterations + + autotest_list.append(autotest) + return autotest_list + + +def CreateAutotestRuns(images, + autotests, + remote, + board, + exact_remote, + rerun, + rerun_if_failed, + main_chromeos_root=None): + autotest_runs = [] + for image in images: + logger.GetLogger().LogOutput('Computing md5sum of: %s' % image) + image_checksum = FileUtils().Md5File(image) + logger.GetLogger().LogOutput('md5sum %s: %s' % (image, image_checksum)) + ### image_checksum = "abcdefghi" + + chromeos_root = main_chromeos_root + if not main_chromeos_root: + image_chromeos_root = os.path.join( + os.path.dirname(image), '../../../../..') + chromeos_root = CanonicalizeChromeOSRoot(image_chromeos_root) + assert chromeos_root, 'chromeos_root: %s invalid' % image_chromeos_root + else: + chromeos_root = CanonicalizeChromeOSRoot(main_chromeos_root) + assert chromeos_root, 'chromeos_root: %s invalid' % main_chromeos_root + + # We just need a single ChromeOS root in the MachineManagerSingleton. It is + # needed because we can save re-image time by checking the image checksum at + # the beginning and assigning autotests to machines appropriately. + if not MachineManagerSingleton().chromeos_root: + MachineManagerSingleton().chromeos_root = chromeos_root + + for autotest in autotests: + for iteration in range(autotest.iterations): + autotest_run = AutotestRun(autotest, + chromeos_root=chromeos_root, + chromeos_image=image, + board=board, + remote=remote, + iteration=iteration, + image_checksum=image_checksum, + exact_remote=exact_remote, + rerun=rerun, + rerun_if_failed=rerun_if_failed) + autotest_runs.append(autotest_run) + return autotest_runs + + +def GetNamesAndIterations(autotest_runs): + strings = [] + for autotest_run in autotest_runs: + strings.append('%s:%s' % (autotest_run.autotest.name, + autotest_run.iteration)) + return ' %s (%s)' % (len(strings), ' '.join(strings)) + + +def GetStatusString(autotest_runs): + status_bins = {} + for autotest_run in autotest_runs: + if autotest_run.status not in status_bins: + status_bins[autotest_run.status] = [] + status_bins[autotest_run.status].append(autotest_run) + + status_strings = [] + for key, val in status_bins.items(): + status_strings.append('%s: %s' % (key, GetNamesAndIterations(val))) + return 'Thread Status:\n%s' % '\n'.join(status_strings) + + +def GetProgressBar(num_done, num_total): + ret = 'Done: %s%%' % int(100.0 * num_done / num_total) + bar_length = 50 + done_char = '>' + undone_char = ' ' + num_done_chars = bar_length * num_done / num_total + num_undone_chars = bar_length - num_done_chars + ret += ' [%s%s]' % (num_done_chars * done_char, + num_undone_chars * undone_char) + return ret + + +def GetProgressString(start_time, num_remain, num_total): + current_time = time.time() + elapsed_time = current_time - start_time + try: + eta_seconds = float(num_remain) * elapsed_time / (num_total - num_remain) + eta_seconds = int(eta_seconds) + eta = datetime.timedelta(seconds=eta_seconds) + except ZeroDivisionError: + eta = 'Unknown' + strings = [] + strings.append('Current time: %s Elapsed: %s ETA: %s' % + (datetime.datetime.now(), + datetime.timedelta(seconds=int(elapsed_time)), eta)) + strings.append(GetProgressBar(num_total - num_remain, num_total)) + return '\n'.join(strings) + + +def RunAutotestRunsInParallel(autotest_runs): + start_time = time.time() + active_threads = [] + for autotest_run in autotest_runs: + # Set threads to daemon so program exits when ctrl-c is pressed. + autotest_run.daemon = True + autotest_run.start() + active_threads.append(autotest_run) + + print_interval = 30 + last_printed_time = time.time() + while active_threads: + try: + active_threads = [t for t in active_threads + if t is not None and t.isAlive()] + for t in active_threads: + t.join(1) + if time.time() - last_printed_time > print_interval: + border = '==============================' + logger.GetLogger().LogOutput(border) + logger.GetLogger().LogOutput(GetProgressString(start_time, len( + [t for t in autotest_runs if t.status not in ['SUCCEEDED', 'FAILED'] + ]), len(autotest_runs))) + logger.GetLogger().LogOutput(GetStatusString(autotest_runs)) + logger.GetLogger().LogOutput('%s\n' % + MachineManagerSingleton().AsString()) + logger.GetLogger().LogOutput(border) + last_printed_time = time.time() + except KeyboardInterrupt: + print 'C-c received... cleaning up threads.' + for t in active_threads: + t.terminate = True + return 1 + return 0 + + +def RunAutotestRunsSerially(autotest_runs): + for autotest_run in autotest_runs: + retval = autotest_run.Run() + if retval: + return retval + + +def ProduceTables(autotest_runs, full_table, fit_string): + l = logger.GetLogger() + ags_dict = {} + for autotest_run in autotest_runs: + name = autotest_run.full_name + if name not in ags_dict: + ags_dict[name] = AutotestGatherer() + ags_dict[name].runs.append(autotest_run) + output = '' + for b, ag in ags_dict.items(): + output += 'Benchmark: %s\n' % b + output += ag.GetFormattedMainTable(percents_only=not full_table, + fit_string=fit_string) + output += '\n' + + summary = '' + for b, ag in ags_dict.items(): + summary += 'Benchmark Summary Table: %s\n' % b + summary += ag.GetFormattedSummaryTable(percents_only=not full_table, + fit_string=fit_string) + summary += '\n' + + output += summary + output += ('Number of re-images performed: %s' % + MachineManagerSingleton().num_reimages) + l.LogOutput(output) + + if autotest_runs: + board = autotest_runs[0].board + else: + board = '' + + subject = '%s: %s' % (board, ', '.join(ags_dict.keys())) + + if any(autotest_run.run_completed for autotest_run in autotest_runs): + SendEmailToUser(subject, summary) + + +def SendEmailToUser(subject, text_to_send): + # Email summary to the current user. + msg = MIMEText(text_to_send) + + # me == the sender's email address + # you == the recipient's email address + me = os.path.basename(__file__) + you = os.getlogin() + msg['Subject'] = '[%s] %s' % (os.path.basename(__file__), subject) + msg['From'] = me + msg['To'] = you + + # Send the message via our own SMTP server, but don't include the + # envelope header. + s = smtplib.SMTP('localhost') + s.sendmail(me, [you], msg.as_string()) + s.quit() + + +def Main(argv): + """The main function.""" + # Common initializations + ### command_executer.InitCommandExecuter(True) + l = logger.GetLogger() + + parser = optparse.OptionParser() + parser.add_option('-t', + '--tests', + dest='tests', + help=('Tests to compare.' + 'Optionally specify per-test iterations by:' + '<test>,<iter>:<args>')) + parser.add_option('-c', + '--chromeos_root', + dest='chromeos_root', + help='A *single* chromeos_root where scripts can be found.') + parser.add_option('-n', + '--iterations', + dest='iterations', + help='Iterations to run per benchmark.', + default=1) + parser.add_option('-r', + '--remote', + dest='remote', + help='The remote chromeos machine.') + parser.add_option('-b', '--board', dest='board', help='The remote board.') + parser.add_option('--full_table', + dest='full_table', + help='Print full tables.', + action='store_true', + default=True) + parser.add_option('--exact_remote', + dest='exact_remote', + help='Run tests on the exact remote.', + action='store_true', + default=False) + parser.add_option('--fit_string', + dest='fit_string', + help='Fit strings to fixed sizes.', + action='store_true', + default=False) + parser.add_option('--rerun', + dest='rerun', + help='Re-run regardless of cache hit.', + action='store_true', + default=False) + parser.add_option('--rerun_if_failed', + dest='rerun_if_failed', + help='Re-run if previous run was a failure.', + action='store_true', + default=False) + parser.add_option('--no_lock', + dest='no_lock', + help='Do not lock the machine before running the tests.', + action='store_true', + default=False) + l.LogOutput(' '.join(argv)) + [options, args] = parser.parse_args(argv) + + if options.remote is None: + l.LogError('No remote machine specified.') + parser.print_help() + return 1 + + if not options.board: + l.LogError('No board specified.') + parser.print_help() + return 1 + + remote = options.remote + tests = options.tests + board = options.board + exact_remote = options.exact_remote + iterations = int(options.iterations) + + autotests = CreateAutotestListFromString(tests, iterations) + + main_chromeos_root = options.chromeos_root + images = args[1:] + fit_string = options.fit_string + full_table = options.full_table + rerun = options.rerun + rerun_if_failed = options.rerun_if_failed + + MachineManagerSingleton().no_lock = options.no_lock + + # Now try creating all the Autotests + autotest_runs = CreateAutotestRuns(images, autotests, remote, board, + exact_remote, rerun, rerun_if_failed, + main_chromeos_root) + + try: + # At this point we have all the autotest runs. + for machine in remote.split(','): + MachineManagerSingleton().AddMachine(machine) + + retval = RunAutotestRunsInParallel(autotest_runs) + if retval: + return retval + + # Now print tables + ProduceTables(autotest_runs, full_table, fit_string) + finally: + # not sure why this isn't called at the end normally... + MachineManagerSingleton().__del__() + + return 0 + + +if __name__ == '__main__': + sys.exit(Main(sys.argv)) diff --git a/deprecated/crb/machine_manager_singleton.py b/deprecated/crb/machine_manager_singleton.py new file mode 100644 index 00000000..6ffe9684 --- /dev/null +++ b/deprecated/crb/machine_manager_singleton.py @@ -0,0 +1,153 @@ +import image_chromeos +import lock_machine +import sys +import threading +import time +from cros_utils import command_executer +from cros_utils import logger + + +class CrosMachine(object): + + def __init__(self, name): + self.name = name + self.image = None + self.checksum = None + self.locked = False + self.released_time = time.time() + self.autotest_run = None + + def __str__(self): + l = [] + l.append(self.name) + l.append(str(self.image)) + l.append(str(self.checksum)) + l.append(str(self.locked)) + l.append(str(self.released_time)) + return ', '.join(l) + + +class MachineManagerSingleton(object): + _instance = None + _lock = threading.RLock() + _all_machines = [] + _machines = [] + image_lock = threading.Lock() + num_reimages = 0 + chromeos_root = None + no_lock = False + + def __new__(cls, *args, **kwargs): + with cls._lock: + if not cls._instance: + cls._instance = super(MachineManagerSingleton, cls).__new__(cls, *args, + **kwargs) + return cls._instance + + def TryToLockMachine(self, cros_machine): + with self._lock: + assert cros_machine, "Machine can't be None" + for m in self._machines: + assert m.name != cros_machine.name, ('Tried to double-lock %s' % + cros_machine.name) + if self.no_lock: + locked = True + else: + locked = lock_machine.Machine(cros_machine.name).Lock(True, sys.argv[0]) + if locked: + ce = command_executer.GetCommandExecuter() + command = 'cat %s' % image_chromeos.checksum_file + ret, out, err = ce.CrosRunCommandWOutput( + command, + chromeos_root=self.chromeos_root, + machine=cros_machine.name) + if ret == 0: + cros_machine.checksum = out.strip() + self._machines.append(cros_machine) + else: + logger.GetLogger().LogOutput("Warning: Couldn't lock: %s" % + cros_machine.name) + + # This is called from single threaded mode. + def AddMachine(self, machine_name): + with self._lock: + for m in self._all_machines: + assert m.name != machine_name, 'Tried to double-add %s' % machine_name + self._all_machines.append(CrosMachine(machine_name)) + + def AcquireMachine(self, image_checksum): + with self._lock: + # Lazily external lock machines + if not self._machines: + for m in self._all_machines: + self.TryToLockMachine(m) + assert self._machines, ('Could not lock any machine in %s' % + self._all_machines) + + ### for m in self._machines: + ### if (m.locked and time.time() - m.released_time < 10 and + ### m.checksum == image_checksum): + ### return None + for m in [machine for machine in self._machines if not machine.locked]: + if m.checksum == image_checksum: + m.locked = True + m.autotest_run = threading.current_thread() + return m + for m in [machine for machine in self._machines if not machine.locked]: + if not m.checksum: + m.locked = True + m.autotest_run = threading.current_thread() + return m + for m in [machine for machine in self._machines if not machine.locked]: + if time.time() - m.released_time > 20: + m.locked = True + m.autotest_run = threading.current_thread() + return m + return None + + def ReleaseMachine(self, machine): + with self._lock: + for m in self._machines: + if machine.name == m.name: + assert m.locked == True, 'Tried to double-release %s' % m.name + m.released_time = time.time() + m.locked = False + m.status = 'Available' + break + + def __del__(self): + with self._lock: + # Unlock all machines. + for m in self._machines: + if not self.no_lock: + assert lock_machine.Machine(m.name).Unlock(True) == True, ( + "Couldn't unlock machine: %s" % m.name) + + def __str__(self): + with self._lock: + l = ['MachineManager Status:'] + for m in self._machines: + l.append(str(m)) + return '\n'.join(l) + + def AsString(self): + with self._lock: + stringify_fmt = '%-30s %-10s %-4s %-25s %-32s' + header = stringify_fmt % ('Machine', 'Thread', 'Lock', 'Status', + 'Checksum') + table = [header] + for m in self._machines: + if m.autotest_run: + autotest_name = m.autotest_run.name + autotest_status = m.autotest_run.status + else: + autotest_name = '' + autotest_status = '' + + try: + machine_string = stringify_fmt % (m.name, autotest_name, m.locked, + autotest_status, m.checksum) + except: + machine_string = '' + table.append(machine_string) + return 'Machine Status:\n%s' % '\n'.join(table) diff --git a/deprecated/crb/table_formatter.py b/deprecated/crb/table_formatter.py new file mode 100644 index 00000000..b8e25d5f --- /dev/null +++ b/deprecated/crb/table_formatter.py @@ -0,0 +1,258 @@ +import numpy +import re + + +def IsFloat(text): + if text is None: + return False + try: + float(text) + return True + except ValueError: + return False + + +def RemoveTrailingZeros(x): + ret = x + ret = re.sub('\.0*$', '', ret) + ret = re.sub('(\.[1-9]*)0+$', '\\1', ret) + return ret + + +def HumanizeFloat(x, n=2): + if not IsFloat(x): + return x + digits = re.findall('[0-9.]', str(x)) + decimal_found = False + ret = '' + sig_figs = 0 + for digit in digits: + if digit == '.': + decimal_found = True + elif sig_figs != 0 or digit != '0': + sig_figs += 1 + if decimal_found and sig_figs >= n: + break + ret += digit + return ret + + +def GetNSigFigs(x, n=2): + if not IsFloat(x): + return x + my_fmt = '%.' + str(n - 1) + 'e' + x_string = my_fmt % x + f = float(x_string) + return f + + +def GetFormattedPercent(baseline, other, bad_result='--'): + result = '%8s' % GetPercent(baseline, other, bad_result) + return result + + +def GetPercent(baseline, other, bad_result='--'): + result = bad_result + if IsFloat(baseline) and IsFloat(other): + try: + pct = (float(other) / float(baseline) - 1) * 100 + result = '%+1.1f' % pct + except ZeroDivisionError: + pass + return result + + +def FitString(text, length): + if len(text) == length: + return text + elif len(text) > length: + return text[-length:] + else: + fmt = '%%%ds' % length + return fmt % text + + +class TableFormatter(object): + + def __init__(self): + self.d = '\t' + self.bad_result = 'x' + + def GetTablePercents(self, table): + # Assumes table is not transposed. + pct_table = [] + + pct_table.append(table[0]) + for i in range(1, len(table)): + row = [] + row.append(table[i][0]) + for j in range(1, len(table[0])): + c = table[i][j] + b = table[i][1] + p = GetPercent(b, c, self.bad_result) + row.append(p) + pct_table.append(row) + return pct_table + + def FormatFloat(self, c, max_length=8): + if not IsFloat(c): + return c + f = float(c) + ret = HumanizeFloat(f, 4) + ret = RemoveTrailingZeros(ret) + if len(ret) > max_length: + ret = '%1.1ef' % f + return ret + + def TransposeTable(self, table): + transposed_table = [] + for i in range(len(table[0])): + row = [] + for j in range(len(table)): + row.append(table[j][i]) + transposed_table.append(row) + return transposed_table + + def GetTableLabels(self, table): + ret = '' + header = table[0] + for i in range(1, len(header)): + ret += '%d: %s\n' % (i, header[i]) + return ret + + def GetFormattedTable(self, + table, + transposed=False, + first_column_width=30, + column_width=14, + percents_only=True, + fit_string=True): + o = '' + pct_table = self.GetTablePercents(table) + if transposed == True: + table = self.TransposeTable(table) + pct_table = self.TransposeTable(table) + + for i in range(0, len(table)): + for j in range(len(table[0])): + if j == 0: + width = first_column_width + else: + width = column_width + + c = table[i][j] + p = pct_table[i][j] + + # Replace labels with numbers: 0... n + if IsFloat(c): + c = self.FormatFloat(c) + + if IsFloat(p) and not percents_only: + p = '%s%%' % p + + # Print percent values side by side. + if j != 0: + if percents_only: + c = '%s' % p + else: + c = '%s (%s)' % (c, p) + + if i == 0 and j != 0: + c = str(j) + + if fit_string: + o += FitString(c, width) + self.d + else: + o += c + self.d + o += '\n' + return o + + def GetGroups(self, table): + labels = table[0] + groups = [] + group_dict = {} + for i in range(1, len(labels)): + label = labels[i] + stripped_label = self.GetStrippedLabel(label) + if stripped_label not in group_dict: + group_dict[stripped_label] = len(groups) + groups.append([]) + groups[group_dict[stripped_label]].append(i) + return groups + + def GetSummaryTableValues(self, table): + # First get the groups + groups = self.GetGroups(table) + + summary_table = [] + + labels = table[0] + + summary_labels = ['Summary Table'] + for group in groups: + label = labels[group[0]] + stripped_label = self.GetStrippedLabel(label) + group_label = '%s (%d runs)' % (stripped_label, len(group)) + summary_labels.append(group_label) + summary_table.append(summary_labels) + + for i in range(1, len(table)): + row = table[i] + summary_row = [row[0]] + for group in groups: + group_runs = [] + for index in group: + group_runs.append(row[index]) + group_run = self.AggregateResults(group_runs) + summary_row.append(group_run) + summary_table.append(summary_row) + + return summary_table + + # Drop N% slowest and M% fastest numbers, and return arithmean of + # the remaining. + @staticmethod + def AverageWithDrops(numbers, slow_percent=20, fast_percent=20): + sorted_numbers = list(numbers) + sorted_numbers.sort() + num_slow = int(slow_percent / 100.0 * len(sorted_numbers)) + num_fast = int(fast_percent / 100.0 * len(sorted_numbers)) + sorted_numbers = sorted_numbers[num_slow:] + if num_fast: + sorted_numbers = sorted_numbers[:-num_fast] + return numpy.average(sorted_numbers) + + @staticmethod + def AggregateResults(group_results): + ret = '' + if not group_results: + return ret + all_floats = True + all_passes = True + all_fails = True + for group_result in group_results: + if not IsFloat(group_result): + all_floats = False + if group_result != 'PASSED': + all_passes = False + if group_result != 'FAILED': + all_fails = False + if all_floats == True: + float_results = [float(v) for v in group_results] + ret = '%f' % TableFormatter.AverageWithDrops(float_results) + # Add this line for standard deviation. + ### ret += " %f" % numpy.std(float_results) + elif all_passes == True: + ret = 'ALL_PASS' + elif all_fails == True: + ret = 'ALL_FAILS' + return ret + + @staticmethod + def GetStrippedLabel(label): + return re.sub('\s*\S+:\S+\s*', '', label) +### return re.sub("\s*remote:\S*\s*i:\d+$", "", label) + + @staticmethod + def GetLabelWithIteration(label, iteration): + return '%s i:%d' % (label, iteration) diff --git a/deprecated/cros_login.py b/deprecated/cros_login.py new file mode 100755 index 00000000..06ff8ff0 --- /dev/null +++ b/deprecated/cros_login.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python2 +# +# Copyright 2010~2015 Google Inc. All Rights Reserved. +"""Script to get past the login screen of ChromeOS.""" + +from __future__ import print_function + +import argparse +import os +import sys +import tempfile + +from cros_utils import command_executer + +LOGIN_PROMPT_VISIBLE_MAGIC_FILE = '/tmp/uptime-login-prompt-visible' +LOGGED_IN_MAGIC_FILE = '/var/run/state/logged-in' + +script_header = """ +import os +import autox +import time +""" + +wait_for_login_screen = """ + +while True: + print 'Waiting for login screen to appear...' + if os.path.isfile('%s'): + break + time.sleep(1) + print 'Done' + +time.sleep(20) +""" % LOGIN_PROMPT_VISIBLE_MAGIC_FILE + +do_login = """ +xauth_filename = '/home/chronos/.Xauthority' +os.environ.setdefault('XAUTHORITY', xauth_filename) +os.environ.setdefault('DISPLAY', ':0.0') + +print 'Now sending the hotkeys for logging in.' +ax = autox.AutoX() +# navigate to login screen +ax.send_hotkey('Ctrl+Shift+q') +ax.send_hotkey('Ctrl+Alt+l') +# escape out of any login screen menus (e.g., the network select menu) +time.sleep(2) +ax.send_hotkey('Escape') +time.sleep(2) +ax.send_hotkey('Tab') +time.sleep(0.5) +ax.send_hotkey('Tab') +time.sleep(0.5) +ax.send_hotkey('Tab') +time.sleep(0.5) +ax.send_hotkey('Tab') +time.sleep(0.5) +ax.send_hotkey('Return') +print 'Waiting for Chrome to appear...' +while True: + if os.path.isfile('%s'): + break + time.sleep(1) +print 'Done' +""" % LOGGED_IN_MAGIC_FILE + + +def RestartUI(remote, chromeos_root, login=True): + chromeos_root = os.path.expanduser(chromeos_root) + ce = command_executer.GetCommandExecuter() + # First, restart ui. + command = 'rm -rf %s && restart ui' % LOGIN_PROMPT_VISIBLE_MAGIC_FILE + ce.CrosRunCommand(command, machine=remote, chromeos_root=chromeos_root) + host_login_script = tempfile.mktemp() + device_login_script = '/tmp/login.py' + login_script_list = [script_header, wait_for_login_screen] + if login: + login_script_list.append(do_login) + + full_login_script_contents = '\n'.join(login_script_list) + + with open(host_login_script, 'w') as f: + f.write(full_login_script_contents) + ce.CopyFiles( + host_login_script, + device_login_script, + dest_machine=remote, + chromeos_root=chromeos_root, + recursive=False, + dest_cros=True) + ret = ce.CrosRunCommand( + 'python %s' % device_login_script, + chromeos_root=chromeos_root, + machine=remote) + if os.path.exists(host_login_script): + os.remove(host_login_script) + return ret + + +def Main(argv): + """The main function.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '-r', '--remote', dest='remote', help='The remote ChromeOS box.') + parser.add_argument( + '-c', '--chromeos_root', dest='chromeos_root', help='The ChromeOS root.') + + options = parser.parse_args(argv) + + return RestartUI(options.remote, options.chromeos_root) + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/cwp/bartlett/app.yaml b/deprecated/cwp/bartlett/app.yaml new file mode 100644 index 00000000..60010f70 --- /dev/null +++ b/deprecated/cwp/bartlett/app.yaml @@ -0,0 +1,22 @@ +application: chromeoswideprofiling +version: 1 +runtime: python +api_version: 1 + +handlers: +- url: /favicon.ico + static_files: static/favicon.ico + upload: static/favicon.ico +- url: /remote_api + script: $PYTHON_LIB/google/appengine/ext/remote_api/handler.py + login: admin +- url: / + script: server.py +- url: /upload + script: server.py +- url: /serve + script: server.py +- url: /serve/.* + script: server.py +- url: /del/.* + script: server.py diff --git a/deprecated/cwp/bartlett/server.py b/deprecated/cwp/bartlett/server.py new file mode 100755 index 00000000..8fb7d61e --- /dev/null +++ b/deprecated/cwp/bartlett/server.py @@ -0,0 +1,153 @@ +#!/usr/bin/python2 +# Copyright 2012 Google Inc. All Rights Reserved. +# Author: mrdmnd@ (Matt Redmond) +# Based off of code in //depot/google3/experimental/mobile_gwp +"""Code to transport profile data between a user's machine and the CWP servers. + Pages: + "/": the main page for the app, left blank so that users cannot access + the file upload but left in the code for debugging purposes + "/upload": Updates the datastore with a new file. the upload depends on + the format which is templated on the main page ("/") + input includes: + profile_data: the zipped file containing profile data + board: the architecture we ran on + chromeos_version: the chromeos_version + "/serve": Lists all of the files in the datastore. Each line is a new entry + in the datastore. The format is key~date, where key is the entry's + key in the datastore and date is the file upload time and date. + (Authentication Required) + "/serve/([^/]+)?": For downloading a file of profile data, ([^/]+)? means + any character sequence so to download the file go to + '/serve/$key' where $key is the datastore key of the file + you want to download. + (Authentication Required) + "/del/([^/]+)?": For deleting an entry in the datastore. To use go to + '/del/$key' where $key is the datastore key of the entry + you want to be deleted form the datastore. + (Authentication Required) + TODO: Add more extensive logging""" + +import cgi +import logging +import md5 +import urllib + +from google.appengine.api import users +from google.appengine.ext import db +from google.appengine.ext import webapp +from google.appengine.ext.webapp.util import run_wsgi_app + +logging.getLogger().setLevel(logging.DEBUG) + + +class FileEntry(db.Model): + profile_data = db.BlobProperty() # The profile data + date = db.DateTimeProperty(auto_now_add=True) # Date it was uploaded + data_md5 = db.ByteStringProperty() # md5 of the profile data + board = db.StringProperty() # board arch + chromeos_version = db.StringProperty() # ChromeOS version + + +class MainPage(webapp.RequestHandler): + """Main page only used as the form template, not actually displayed.""" + + def get(self, response=''): # pylint: disable-msg=C6409 + if response: + self.response.out.write('<html><body>') + self.response.out.write("""<br> + <form action="/upload" enctype="multipart/form-data" method="post"> + <div><label>Profile Data:</label></div> + <div><input type="file" name="profile_data"/></div> + <div><label>Board</label></div> + <div><input type="text" name="board"/></div> + <div><label>ChromeOS Version</label></div> + <div><input type="text" name="chromeos_version"></div> + <div><input type="submit" value="send" name="submit"></div> + </form> + </body> + </html>""") + + +class Upload(webapp.RequestHandler): + """Handler for uploading data to the datastore, accessible by anyone.""" + + def post(self): # pylint: disable-msg=C6409 + """Takes input based on the main page's form.""" + getfile = FileEntry() + f1 = self.request.get('profile_data') + getfile.profile_data = db.Blob(f1) + getfile.data_md5 = md5.new(f1).hexdigest() + getfile.board = self.request.get('board') + getfile.chromeos_version = self.request.get('chromeos_version') + getfile.put() + self.response.out.write(getfile.key()) + #self.redirect('/') + + +class ServeHandler(webapp.RequestHandler): + """Given the entry's key in the database, output the profile data file. Only + accessible from @google.com accounts.""" + + def get(self, resource): # pylint: disable-msg=C6409 + if Authenticate(self): + file_key = str(urllib.unquote(resource)) + request = db.get(file_key) + self.response.out.write(request.profile_data) + + +class ListAll(webapp.RequestHandler): + """Displays all files uploaded. Only accessible by @google.com accounts.""" + + def get(self): # pylint: disable-msg=C6409 + """Displays all information in FileEntry, ~ delimited.""" + if Authenticate(self): + query_str = 'SELECT * FROM FileEntry ORDER BY date ASC' + query = db.GqlQuery(query_str) + delimiter = '~' + + for item in query: + display_list = [item.key(), item.date, item.data_md5, item.board, + item.chromeos_version] + str_list = [cgi.escape(str(i)) for i in display_list] + self.response.out.write(delimiter.join(str_list) + '</br>') + + +class DelEntries(webapp.RequestHandler): + """Deletes entries. Only accessible from @google.com accounts.""" + + def get(self, resource): # pylint: disable-msg=C6409 + """A specific entry is deleted, when the key is given.""" + if Authenticate(self): + fkey = str(urllib.unquote(resource)) + request = db.get(fkey) + if request: + db.delete(fkey) + + +def Authenticate(webpage): + """Some urls are only accessible if logged in with a @google.com account.""" + user = users.get_current_user() + if user is None: + webpage.redirect(users.create_login_url(webpage.request.uri)) + elif user.email().endswith('@google.com'): + return True + else: + webpage.response.out.write('Not Authenticated') + return False + + +def main(): + application = webapp.WSGIApplication( + [ + ('/', MainPage), + ('/upload', Upload), + ('/serve/([^/]+)?', ServeHandler), + ('/serve', ListAll), + ('/del/([^/]+)?', DelEntries), + ], + debug=False) + run_wsgi_app(application) + + +if __name__ == '__main__': + main() diff --git a/deprecated/cwp/bartlett/static/favicon.ico b/deprecated/cwp/bartlett/static/favicon.ico Binary files differnew file mode 100644 index 00000000..19b58c2e --- /dev/null +++ b/deprecated/cwp/bartlett/static/favicon.ico diff --git a/deprecated/cwp/bartlett/test/server_tester.py b/deprecated/cwp/bartlett/test/server_tester.py new file mode 100644 index 00000000..585da43a --- /dev/null +++ b/deprecated/cwp/bartlett/test/server_tester.py @@ -0,0 +1,101 @@ +# Copyright 2012 Google Inc. All Rights Reserved. +# Author: mrdmnd@ (Matt Redmond) +"""A unit test for sending data to Bartlett. Requires poster module.""" + +import cookielib +import os +import signal +import subprocess +import tempfile +import time +import unittest +import urllib2 + +from poster.encode import multipart_encode +from poster.streaminghttp import register_openers + +SERVER_DIR = '../.' +SERVER_URL = 'http://localhost:8080/' +GET = '_ah/login?email=googler@google.com&action=Login&continue=%s' +AUTH_URL = SERVER_URL + GET + + +class ServerTest(unittest.TestCase): + """A unit test for the bartlett server. Tests upload, serve, and delete.""" + + def setUp(self): + """Instantiate the files and server needed to test upload functionality.""" + self._server_proc = LaunchLocalServer() + self._jar = cookielib.LWPCookieJar() + self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self._jar)) + + # We need these files to not delete when closed, because we have to reopen + # them in read mode after we write and close them. + self.profile_data = tempfile.NamedTemporaryFile(delete=False) + + size = 16 * 1024 + self.profile_data.write(os.urandom(size)) + + def tearDown(self): + self.profile_data.close() + os.remove(self.profile_data.name) + os.kill(self._server_proc.pid, signal.SIGINT) + + def testIntegration(self): # pylint: disable-msg=C6409 + key = self._testUpload() + self._testListAll() + self._testServeKey(key) + self._testDelKey(key) + + def _testUpload(self): # pylint: disable-msg=C6409 + register_openers() + data = {'profile_data': self.profile_data, + 'board': 'x86-zgb', + 'chromeos_version': '2409.0.2012_06_08_1114'} + datagen, headers = multipart_encode(data) + request = urllib2.Request(SERVER_URL + 'upload', datagen, headers) + response = urllib2.urlopen(request).read() + self.assertTrue(response) + return response + + def _testListAll(self): # pylint: disable-msg=C6409 + request = urllib2.Request(AUTH_URL % (SERVER_URL + 'serve')) + response = self.opener.open(request).read() + self.assertTrue(response) + + def _testServeKey(self, key): # pylint: disable-msg=C6409 + request = urllib2.Request(AUTH_URL % (SERVER_URL + 'serve/' + key)) + response = self.opener.open(request).read() + self.assertTrue(response) + + def _testDelKey(self, key): # pylint: disable-msg=C6409 + # There is no response to a delete request. + # We will check the listAll page to ensure there is no data. + request = urllib2.Request(AUTH_URL % (SERVER_URL + 'del/' + key)) + response = self.opener.open(request).read() + request = urllib2.Request(AUTH_URL % (SERVER_URL + 'serve')) + response = self.opener.open(request).read() + self.assertFalse(response) + + +def LaunchLocalServer(): + """Launch and store an authentication cookie with a local server.""" + proc = subprocess.Popen( + ['dev_appserver.py', '--clear_datastore', SERVER_DIR], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + # Wait for server to come up + while True: + time.sleep(1) + try: + request = urllib2.Request(SERVER_URL + 'serve') + response = urllib2.urlopen(request).read() + if response: + break + except urllib2.URLError: + continue + return proc + + +if __name__ == '__main__': + unittest.main() diff --git a/deprecated/cwp/bartlett/update_appengine_server b/deprecated/cwp/bartlett/update_appengine_server new file mode 100755 index 00000000..f3812057 --- /dev/null +++ b/deprecated/cwp/bartlett/update_appengine_server @@ -0,0 +1 @@ +appcfg.py --oauth2 update . diff --git a/deprecated/cwp/demo_pipeline.sh b/deprecated/cwp/demo_pipeline.sh new file mode 100644 index 00000000..d45c5c44 --- /dev/null +++ b/deprecated/cwp/demo_pipeline.sh @@ -0,0 +1,55 @@ +#!/bin/bash + +# These should be on the local filesystem. We'll be hitting it hard. +DATA_DIR=/usr/local/google/home/${USER}/ +SYMBOL_CACHE=${DATA_DIR}cache/ +REPORT_DIR=${DATA_DIR}reports/ +SAMPLE_DIR=${DATA_DIR}samples/ +RECORD_FILE=/tmp/profiles.rio +COLUMN_FILE=/tmp/profiles.cio +mkdir -p ${SYMBOL_CACHE} +mkdir -p ${REPORT_DIR} +mkdir -p ${SAMPLE_DIR} + +# Directory that has the scripts app_engine_pull.py and symbolizer.py +INTERPRETER_DIR=/google/src/files/p2/head/depot2/gcctools/chromeos/v14/cwp/interpreter/ +V14_DIR=$(dirname $(dirname ${INTERPRETER_DIR})) + +PYTHONPATH=$PYTHONPATH:$V14_DIR + +# Profile util binary +PROFILE_UTIL_BINARY=/home/mrdmnd/${USER}-profiledb/google3/blaze-bin/perftools/gwp/chromeos/profile_util + +# mr-convert binary +MR_CONVERT_BINARY=/home/build/static/projects/dremel/mr-convert + +CNS_LOC=/cns/ag-d/home/${USER}/profiledb/ + +# Protofile location +PROTO_LOC=${CNS_LOC}cwp_profile_db_entry.proto + +echo "0. Cleaning up old data." +rm /tmp/profiles.* +rm ${REPORT_DIR}* +rm ${SAMPLE_DIR}* + + +echo "Starting CWP Pipeline..." +echo "1. Pulling samples to local filesystem from server." +echo " For demo purposes, UN=${USER}@google.com, PW=xjpbmshkzefutlrm" +python ${INTERPRETER_DIR}app_engine_pull.py --output_dir=${SAMPLE_DIR} +echo "2. Symbolizing samples to perf reports. Hold on..." + +python ${INTERPRETER_DIR}symbolizer.py --in=${SAMPLE_DIR} --out=${REPORT_DIR} --cache=${SYMBOL_CACHE} +echo "3. Loading reports into RecordIO format..." +# Will need to make append_dir more clever / incremental +${PROFILE_UTIL_BINARY} --record=${RECORD_FILE} --append_dir=${REPORT_DIR} +echo "Done." +echo "4. Converting records to columnio." +${MR_CONVERT_BINARY} --mapreduce_input_map=recordio:${RECORD_FILE} --mapreduce_output_map=${COLUMN_FILE}@1 --columnio_mroutput_message_type=CwpProfileDbEntry --columnio_mroutput_protofiles=${PROTO_LOC} +echo "5. Uploading columnio to colossus." +fileutil cp -f /tmp/profiles.cio-* ${CNS_LOC} +echo "6. Let's try some dremel queries..." +echo " dremel> define table t /cns/ag-d/home/${USER}/profiledb/profiles.cio-*" +echo " Like, say, dremel> select sum(frames.count) as count, left(frames.function_name, 80) as name from t group by name order by count desc limit 25;" + diff --git a/deprecated/cwp/interpreter/app_engine_pull.py b/deprecated/cwp/interpreter/app_engine_pull.py new file mode 100644 index 00000000..d092e2a3 --- /dev/null +++ b/deprecated/cwp/interpreter/app_engine_pull.py @@ -0,0 +1,253 @@ +# Copyright 2012 Google Inc. All Rights Reserved. +# Author: mrdmnd@ (Matt Redmond) +"""A client to pull data from Bartlett. + +Inspired by //depot/google3/experimental/mobile_gwp/database/app_engine_pull.py + +The server houses perf.data.gz, board, chrome version for each upload. +This script first authenticates with a proper @google.com account, then +downloads a sample (if it's not already cached) and unzips perf.data + + Authenticate(): Gets login info and returns an auth token + DownloadSamples(): Download and unzip samples. + _GetServePage(): Pulls /serve page from the app engine server + _DownloadSampleFromServer(): Downloads a local compressed copy of a sample + _UncompressSample(): Decompresses a sample, deleting the compressed version. +""" +import cookielib +import getpass +import gzip +import optparse +import os +import urllib +import urllib2 + +SERVER_NAME = 'http://chromeoswideprofiling.appspot.com' +APP_NAME = 'chromeoswideprofiling' +DELIMITER = '~' + + +def Authenticate(server_name): + """Gets credentials from user and attempts to retrieve auth token. + TODO: Accept OAuth2 instead of password. + Args: + server_name: (string) URL that the app engine code is living on. + Returns: + authtoken: (string) The authorization token that can be used + to grab other pages. + """ + + if server_name.endswith('/'): + server_name = server_name.rstrip('/') + # Grab username and password from user through stdin. + username = raw_input('Email (must be @google.com account): ') + password = getpass.getpass('Password: ') + # Use a cookie to authenticate with GAE. + cookiejar = cookielib.LWPCookieJar() + opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookiejar)) + urllib2.install_opener(opener) + # Get an AuthToken from Google accounts service. + auth_uri = 'https://www.google.com/accounts/ClientLogin' + authreq_data = urllib.urlencode({'Email': username, + 'Passwd': password, + 'service': 'ah', + 'source': APP_NAME, + 'accountType': 'HOSTED_OR_GOOGLE'}) + auth_req = urllib2.Request(auth_uri, data=authreq_data) + try: + auth_resp = urllib2.urlopen(auth_req) + except urllib2.URLError: + print 'Error logging in to Google accounts service.' + return None + body = auth_resp.read() + # Auth response contains several fields. + # We care about the part after Auth= + auth_resp_dict = dict(x.split('=') for x in body.split('\n') if x) + authtoken = auth_resp_dict['Auth'] + return authtoken + + +def DownloadSamples(server_name, authtoken, output_dir, start, stop): + """Download every sample and write unzipped version + to output directory. + Args: + server_name: (string) URL that the app engine code is living on. + authtoken: (string) Authorization token. + output_dir (string) Filepath to write output to. + start: (int) Index to start downloading from, starting at top. + stop: (int) Index to stop downloading, non-inclusive. -1 for end. + Returns: + None + """ + + if server_name.endswith('/'): + server_name = server_name.rstrip('/') + + serve_page_string = _GetServePage(server_name, authtoken) + if serve_page_string is None: + print 'Error getting /serve page.' + return + + sample_list = serve_page_string.split('</br>') + print 'Will download:' + sample_list_subset = sample_list[start:stop] + for sample in sample_list_subset: + print sample + for sample in sample_list_subset: + assert sample, 'Sample should be valid.' + sample_info = [s.strip() for s in sample.split(DELIMITER)] + key = sample_info[0] + time = sample_info[1] + time = time.replace(' ', '_') # No space between date and time. + # sample_md5 = sample_info[2] + board = sample_info[3] + version = sample_info[4] + + # Put a compressed copy of the samples in output directory. + _DownloadSampleFromServer(server_name, authtoken, key, time, board, version, + output_dir) + _UncompressSample(key, time, board, version, output_dir) + + +def _BuildFilenameFromParams(key, time, board, version): + """Return the filename for our sample. + Args: + key: (string) Key indexing our sample in the datastore. + time: (string) Date that the sample was uploaded. + board: (string) Board that the sample was taken on. + version: (string) Version string from /etc/lsb-release + Returns: + filename (string) + """ + filename = DELIMITER.join([key, time, board, version]) + return filename + + +def _DownloadSampleFromServer(server_name, authtoken, key, time, board, version, + output_dir): + """Downloads sample_$(samplekey).gz to current dir. + Args: + server_name: (string) URL that the app engine code is living on. + authtoken: (string) Authorization token. + key: (string) Key indexing our sample in the datastore + time: (string) Date that the sample was uploaded. + board: (string) Board that the sample was taken on. + version: (string) Version string from /etc/lsb-release + output_dir: (string) Filepath to write to output to. + Returns: + None + """ + filename = _BuildFilenameFromParams(key, time, board, version) + compressed_filename = filename + '.gz' + + if os.path.exists(os.path.join(output_dir, filename)): + print 'Already downloaded %s, skipping.' % filename + return + + serv_uri = server_name + '/serve/' + key + serv_args = {'continue': serv_uri, 'auth': authtoken} + full_serv_uri = server_name + '/_ah/login?%s' % urllib.urlencode(serv_args) + serv_req = urllib2.Request(full_serv_uri) + serv_resp = urllib2.urlopen(serv_req) + f = open(os.path.join(output_dir, compressed_filename), 'w+') + f.write(serv_resp.read()) + f.close() + + +def _UncompressSample(key, time, board, version, output_dir): + """Uncompresses a given sample.gz file and deletes the compressed version. + Args: + key: (string) Sample key to uncompress. + time: (string) Date that the sample was uploaded. + board: (string) Board that the sample was taken on. + version: (string) Version string from /etc/lsb-release + output_dir: (string) Filepath to find sample key in. + Returns: + None + """ + filename = _BuildFilenameFromParams(key, time, board, version) + compressed_filename = filename + '.gz' + + if os.path.exists(os.path.join(output_dir, filename)): + print 'Already decompressed %s, skipping.' % filename + return + + out_file = open(os.path.join(output_dir, filename), 'wb') + in_file = gzip.open(os.path.join(output_dir, compressed_filename), 'rb') + out_file.write(in_file.read()) + in_file.close() + out_file.close() + os.remove(os.path.join(output_dir, compressed_filename)) + + +def _DeleteSampleFromServer(server_name, authtoken, key): + """Opens the /delete page with the specified key + to delete the sample off the datastore. + Args: + server_name: (string) URL that the app engine code is living on. + authtoken: (string) Authorization token. + key: (string) Key to delete. + Returns: + None + """ + + serv_uri = server_name + '/del/' + key + serv_args = {'continue': serv_uri, 'auth': authtoken} + full_serv_uri = server_name + '/_ah/login?%s' % urllib.urlencode(serv_args) + serv_req = urllib2.Request(full_serv_uri) + urllib2.urlopen(serv_req) + + +def _GetServePage(server_name, authtoken): + """Opens the /serve page and lists all keys. + Args: + server_name: (string) URL the app engine code is living on. + authtoken: (string) Authorization token. + Returns: + The text of the /serve page (including HTML tags) + """ + + serv_uri = server_name + '/serve' + serv_args = {'continue': serv_uri, 'auth': authtoken} + full_serv_uri = server_name + '/_ah/login?%s' % urllib.urlencode(serv_args) + serv_req = urllib2.Request(full_serv_uri) + serv_resp = urllib2.urlopen(serv_req) + return serv_resp.read() + + +def main(): + parser = optparse.OptionParser() + parser.add_option('--output_dir', + dest='output_dir', + action='store', + help='Path to output perf data files.') + parser.add_option('--start', + dest='start_ind', + action='store', + default=0, + help='Start index.') + parser.add_option('--stop', + dest='stop_ind', + action='store', + default=-1, + help='Stop index.') + options = parser.parse_args()[0] + if not options.output_dir: + print 'Must specify --output_dir.' + return 1 + if not os.path.exists(options.output_dir): + print 'Specified output_dir does not exist.' + return 1 + + authtoken = Authenticate(SERVER_NAME) + if not authtoken: + print 'Could not obtain authtoken, exiting.' + return 1 + DownloadSamples(SERVER_NAME, authtoken, options.output_dir, options.start_ind, + options.stop_ind) + print 'Downloaded samples.' + return 0 + + +if __name__ == '__main__': + exit(main()) diff --git a/deprecated/cwp/interpreter/symbolizer.py b/deprecated/cwp/interpreter/symbolizer.py new file mode 100644 index 00000000..4ece480d --- /dev/null +++ b/deprecated/cwp/interpreter/symbolizer.py @@ -0,0 +1,129 @@ +# Copyright 2012 Google Inc. All Rights Reserved. +"""A script that symbolizes perf.data files.""" +import optparse +import os +import shutil +from subprocess import call +from subprocess import PIPE +from subprocess import Popen +from cros_utils import misc + +GSUTIL_CMD = 'gsutil cp gs://chromeos-image-archive/%s-release/%s/debug.tgz %s' +TAR_CMD = 'tar -zxvf %s -C %s' +PERF_BINARY = '/google/data/ro/projects/perf/perf' +VMLINUX_FLAG = ' --vmlinux=/usr/lib/debug/boot/vmlinux' +PERF_CMD = PERF_BINARY + ' report -i %s -n --symfs=%s' + VMLINUX_FLAG + + +def main(): + parser = optparse.OptionParser() + parser.add_option('--in', dest='in_dir') + parser.add_option('--out', dest='out_dir') + parser.add_option('--cache', dest='cache') + (opts, _) = parser.parse_args() + if not _ValidateOpts(opts): + return 1 + else: + for filename in os.listdir(opts.in_dir): + try: + _DownloadSymbols(filename, opts.cache) + _PerfReport(filename, opts.in_dir, opts.out_dir, opts.cache) + except: + print 'Exception caught. Continuing...' + return 0 + + +def _ValidateOpts(opts): + """Ensures all directories exist, before attempting to populate.""" + if not os.path.exists(opts.in_dir): + print "Input directory doesn't exist." + return False + if not os.path.exists(opts.out_dir): + print "Output directory doesn't exist. Creating it..." + os.makedirs(opts.out_dir) + if not os.path.exists(opts.cache): + print "Cache directory doesn't exist." + return False + return True + + +def _ParseFilename(filename, canonical=False): + """Returns a tuple (key, time, board, lsb_version). + If canonical is True, instead returns (database_key, board, canonical_vers) + canonical_vers includes the revision string. + """ + key, time, board, vers = filename.split('~') + if canonical: + vers = misc.GetChromeOSVersionFromLSBVersion(vers) + return (key, time, board, vers) + + +def _FormReleaseDir(board, version): + return '%s-release~%s' % (board, version) + + +def _DownloadSymbols(filename, cache): + """ Incrementally downloads appropriate symbols. + We store the downloads in cache, with each set of symbols in a TLD + named like cache/$board-release~$canonical_vers/usr/lib/debug + """ + _, _, board, vers = _ParseFilename(filename, canonical=True) + tmp_suffix = '.tmp' + + tarball_subdir = _FormReleaseDir(board, vers) + tarball_dir = os.path.join(cache, tarball_subdir) + tarball_path = os.path.join(tarball_dir, 'debug.tgz') + + symbol_subdir = os.path.join('usr', 'lib') + symbol_dir = os.path.join(tarball_dir, symbol_subdir) + + if os.path.isdir(symbol_dir): + print 'Symbol directory %s exists, skipping download.' % symbol_dir + return + else: + # First download using gsutil. + if not os.path.isfile(tarball_path): + download_cmd = GSUTIL_CMD % (board, vers, tarball_path + tmp_suffix) + print 'Downloading symbols for %s' % filename + print download_cmd + ret = call(download_cmd.split()) + if ret != 0: + print 'gsutil returned non-zero error code: %s.' % ret + # Clean up the empty directory structures. + os.remove(tarball_path + tmp_suffix) + raise IOError + + shutil.move(tarball_path + tmp_suffix, tarball_path) + + # Next, untar the tarball. + os.makedirs(symbol_dir + tmp_suffix) + extract_cmd = TAR_CMD % (tarball_path, symbol_dir + tmp_suffix) + print 'Extracting symbols for %s' % filename + print extract_cmd + ret = call(extract_cmd.split()) + if ret != 0: + print 'tar returned non-zero code: %s.' % ret + raise IOError + shutil.move(symbol_dir + tmp_suffix, symbol_dir) + os.remove(tarball_path) + + +def _PerfReport(filename, in_dir, out_dir, cache): + """ Call perf report on the file, storing output to the output dir. + The output is currently stored as $out_dir/$filename + """ + _, _, board, vers = _ParseFilename(filename, canonical=True) + symbol_cache_tld = _FormReleaseDir(board, vers) + input_file = os.path.join(in_dir, filename) + symfs = os.path.join(cache, symbol_cache_tld) + report_cmd = PERF_CMD % (input_file, symfs) + print 'Reporting.' + print report_cmd + report_proc = Popen(report_cmd.split(), stdout=PIPE) + outfile = open(os.path.join(out_dir, filename), 'w') + outfile.write(report_proc.stdout.read()) + outfile.close() + + +if __name__ == '__main__': + exit(main()) diff --git a/deprecated/cwp/performance/experiment_gen.py b/deprecated/cwp/performance/experiment_gen.py new file mode 100644 index 00000000..a12da2c5 --- /dev/null +++ b/deprecated/cwp/performance/experiment_gen.py @@ -0,0 +1,138 @@ +# Copyright 2012 Google Inc. All Rights Reserved. +"""This script generates a crosperf overhead-testing experiment file for MoreJS. + +Use: experiment_gen.py --crosperf=/home/mrdmnd/depot2/crosperf --chromeos_root= +/home/mrdmnd/chromiumos --remote-host=chromeos-zgb3.mtv --board=x86-zgb --event= +cycles -F 10 -F 20 -c 10582 -c 10785211 --perf_options="-g" +""" + +import optparse +import subprocess +import sys +import time + +HEADER = """ +board: %s +remote: %s +benchmark: baseline { + iterations: %s + autotest_name: desktopui_PyAutoPerfTests + autotest_args: --args='--iterations=%s perf.PageCyclerTest.testMoreJSFile' +}""" + +EXPERIMENT = """ +benchmark: %s { + iterations: %s + autotest_name: desktopui_PyAutoPerfTests + autotest_args: --args='--iterations=%s perf.PageCyclerTest.testMoreJSFile' --profiler=custom_perf --profiler_args='perf_options="record -a %s %s -e %s"' \n}""" # pylint: disable-msg=C6310 + +DEFAULT_IMAGE = """ +default { + chromeos_image: %s/src/build/images/%s/latest/chromiumos_test_image.bin +}""" + + +def main(): + parser = optparse.OptionParser() + parser.add_option('--crosperf', + dest='crosperf_root', + action='store', + default='/home/mrdmnd/depot2/crosperf', + help='Crosperf root directory.') + parser.add_option('--chromeos_root', + dest='chromeos_root', + action='store', + default='/home/mrdmnd/chromiumos', + help='ChromiumOS root directory.') + parser.add_option('--remote', + dest='remote', + action='store', + help='Host to run test on. Required.') + parser.add_option('--board', + dest='board', + action='store', + help='Board architecture to run on. Required.') + parser.add_option('--event', + dest='event', + action='store', + help='Event to profile. Required.') + parser.add_option('-F', + dest='sampling_frequencies', + action='append', + help='A target frequency to sample at.') + parser.add_option('-c', + dest='sampling_periods', + action='append', + help='A target period to sample at. Event specific.') + parser.add_option('--benchmark-iterations', + dest='benchmark_iterations', + action='store', + default=4, + help='Number of benchmark iters') + parser.add_option('--test-iterations', + dest='test_iterations', + action='store', + default=10, + help='Number of test iters') + parser.add_option('-p', + dest='print_only', + action='store_true', + help='If enabled, will print experiment file and exit.') + parser.add_option('--perf_options', + dest='perf_options', + action='store', + help='Arbitrary flags to perf. Surround with dblquotes.') + options = parser.parse_args()[0] + if options.remote is None: + print '%s requires a remote hostname.' % sys.argv[0] + return 1 + elif options.board is None: + print '%s requires a target board.' % sys.argv[0] + return 1 + elif options.event is None: + print '%s requires an event to profile.' % sys.argv[0] + return 1 + else: + crosperf_root = options.crosperf_root + chromeos_root = options.chromeos_root + remote = options.remote + board = options.board + event = options.event + bench_iters = options.benchmark_iterations + test_iters = options.test_iterations + perf_opts = options.perf_options + # Set up baseline test. + experiment_file = HEADER % (board, remote, bench_iters, test_iters) + # Set up experimental tests. + if options.sampling_frequencies: + for freq in options.sampling_frequencies: + test_string = str(freq) + 'Freq' + experiment_file += EXPERIMENT % (test_string, bench_iters, test_iters, + '-F %s' % freq, '' if perf_opts is None + else perf_opts, event) + if options.sampling_periods: + for period in options.sampling_periods: + test_string = str(period) + 'Period' + experiment_file += EXPERIMENT % ( + test_string, bench_iters, test_iters, '-c %s' % period, '' if + perf_opts is None else perf_opts, event) + # Point to the target image. + experiment_file += DEFAULT_IMAGE % (chromeos_root, board) + if options.print_only: + print experiment_file + else: + current_time = int(round(time.time() * 1000)) + file_name = 'perf_overhead_%s' % str(current_time) + with open(file_name, 'w') as f: + f.write(experiment_file) + try: + process = subprocess.Popen(['%s/crosperf' % crosperf_root, file_name]) + process.communicate() + except OSError: + print 'Could not find crosperf, make sure --crosperf flag is set right.' + return 1 + return 0 + + +if __name__ == '__main__': + exit(main()) diff --git a/deprecated/dejagnu/__init__.py b/deprecated/dejagnu/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/deprecated/dejagnu/__init__.py @@ -0,0 +1 @@ + diff --git a/deprecated/dejagnu/boards/chromeos-machine.exp b/deprecated/dejagnu/boards/chromeos-machine.exp new file mode 100644 index 00000000..b168b677 --- /dev/null +++ b/deprecated/dejagnu/boards/chromeos-machine.exp @@ -0,0 +1,13 @@ +# Base description of a unix machine. This includes remote execution logic +# through SSH + +load_base_board_description "unix" + +# Set hostname and username. # Make sure SSH keys are set up prior to run. +set_board_info hostname $env(DEJAGNU_HOSTNAME) +set_board_info username root + +set_board_info shell_prompt "dejagnu>" +set chromeos_ssh_opts "-t -o StrictHostKeyChecking=no -o UserKnownHostsFile=/tmp/chromeos-toolchain/known_hosts -o ControlPath=/tmp/chromeos-toolchain/%r@%h:%p -i /tmp/chromeos-toolchain/private_key" +set_board_info rsh_prog "alarm 40 /usr/bin/ssh ${chromeos_ssh_opts}" +set_board_info rcp_prog "alarm 40 /usr/bin/scp ${chromeos_ssh_opts}" diff --git a/deprecated/dejagnu/boards/gdb.exp.in b/deprecated/dejagnu/boards/gdb.exp.in new file mode 100644 index 00000000..e4bbab39 --- /dev/null +++ b/deprecated/dejagnu/boards/gdb.exp.in @@ -0,0 +1,133 @@ +# Copyright 2011-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# This file is a dejagnu "board file" and is used to run the testsuite +# natively with gdbserver. +# +# To use this file: +# bash$ touch ${my_dejagnu_dir}/my-dejagnu.exp +# bash$ export DEJAGNU=${my_dejagnu_dir}/my-dejagnu.exp +# bash$ mkdir ${my_dejagnu_dir}/boards +# bash$ cp ${src_dir}/gdb/testsuite/boards/native-gdbserver.exp \ +# ${my_dejagnu_dir}/boards +# bash$ cd ${build_dir}/gdb +# bash$ make check RUNTESTFLAGS="--target_board=native-gdbserver" + +load_generic_config "gdbserver" +process_multilib_options "" + +# The default compiler for this target. +set_board_info compiler "[find_gcc]" + +set_board_info cflags "-fno-stack-protector" +set_board_info cxxflags "-fno-stack-protector" + +set remote_directory "/tmp" +set chrome_device_ip __board_hostname__ + +# This gdbserver can only run a process once per session. +set_board_info gdb,do_reload_on_run 1 + +# There's no support for argument-passing (yet). +set_board_info noargs 1 + +# Can't do input (or output) in the current gdbserver. +set_board_info gdb,noinferiorio 1 + +# gdbserver does not intercept target file operations and perform them +# on the host. +set_board_info gdb,nofileio 1 + +#set_board_info sockethost "localhost:" +set_board_info use_gdb_stub 1 + +# We will be using the standard GDB remote protocol. +set_board_info gdb_protocol "remote" + +# Test the copy of gdbserver in the build directory. +# set_board_info gdb_server_prog "../gdbserver/gdbserver" + +# Can't do hardware watchpoints, in general (it depends on gdbserver support for your target arch) +set_board_info gdb,no_hardware_watchpoints 1 + +#Can't do record +set_board_info gdb,use_precord 0 +set_board_info gdb,can_reverse 0 + + +set gdb_test_timeout 100 +set_board_info timeout 100 + +set_board_info ssh,options "-i __tmp_testing_rsa__ -o ControlMaster=auto -o ControlPath=__tmp_dir__/%r@%h:%p -o StrictHostKeyChecking=no" + +set_board_info gdb_server_prog "__tmp_dir__/boards/gdbserver.sh " +set_board_info sockethost "__board_hostname__:" +set_board_info protocol standard +set_board_info gdb,socketport "1234" + + +proc ${board}_spawn { board cmd } { + global board_info + + set baseboard [lindex [split $board "/"] 0] + + set board_info($baseboard,isremote) 0 + set result [remote_spawn $board $cmd] + set board_info($baseboard,isremote) 1 + + return $result +} + +proc ${board}_exec { hostname program args } { + global board_info + verbose -log "$hostname $program $args" + set baseboard [lindex [split $hostname "/"] 0] + + set board_info($baseboard,isremote) 0 + set result [remote_exec $hostname $program $args] + set board_info($baseboard,isremote) 1 + + return $result +} + +proc ${board}_download { board host dest } { + verbose -log "chrome_download $board $host $dest" + global board_info + set ssh_options [board_info $board ssh,options] + + global chrome_device_ip remote_directory remote_file + + verbose -log "scp -q $ssh_options $host root@$chrome_device_ip:$remote_directory/$dest" + set status [catch "exec scp -q $ssh_options $host root@$chrome_device_ip:$remote_directory/$dest" output] + + if { $status == 0 } { + verbose -log "Copied $host to $remote_directory/$dest" 2 + return "$remote_directory/$dest" + } else{ + verbose -log "Download to $dest failed, $output." 2 + return "" + } +} + +proc ${board}_file { dest op args } { + if { $op == "delete" } { + return 0 + } + return [eval [list standard_file $dest $op] $args] +} + +proc skip_shlid_tests {} { + return 1 +} diff --git a/deprecated/dejagnu/boards/gdbserver.sh.in b/deprecated/dejagnu/boards/gdbserver.sh.in new file mode 100644 index 00000000..b74c685c --- /dev/null +++ b/deprecated/dejagnu/boards/gdbserver.sh.in @@ -0,0 +1,12 @@ +#!/bin/bash + +REMOTE_SSH_FLAGS="-i __tmp_testing_rsa__ -o StrictHostKeyChecking=no -o CheckHostIP=no -o BatchMode=yes -o ControlMaster=auto -o ControlPath=__tmp_dir__/%r@%h:%p" +FLAGS_remote=__board_hostname__ + +gdbserver_cmd="/usr/local/bin/gdbserver $1 $2 $3" +ssh_cmd="nohup ${gdbserver_cmd} " + +echo "Executing: ssh ${RSA_FILE} ${REMOTE_SSH_FLAGS} root@${FLAGS_remote} \"${ssh_cmd}\"" >&2 + +ssh ${REMOTE_SSH_FLAGS} root@${FLAGS_remote} "killall -9 gdbserver; ${ssh_cmd}" + diff --git a/deprecated/dejagnu/chromeos.exp.in b/deprecated/dejagnu/chromeos.exp.in new file mode 100644 index 00000000..02fc3af2 --- /dev/null +++ b/deprecated/dejagnu/chromeos.exp.in @@ -0,0 +1,175 @@ +# +# Initialize the board. The function is executed before any test. +# +proc __boardname___init { board } { + set hostname [board_info $board hostname] + set timeout [board_info $board timeout] + set ssh_options [board_info $board ssh,options] + set runtimes [board_info $board runtimes] + set tmpdir [board_info $board tmpdir] + verbose -log "Opening persistent connection ..." 1 + eval "exec ssh -N -f $ssh_options root@$hostname &" + local_exec "ssh -n $ssh_options root@$hostname sh -c 'mkdir -p $tmpdir'" \ + {} {} $timeout +} + +# +# Remove test run by-products. The function is executed at DejaGNU exit. +# +proc __boardname___exit {} { + set board "__boardname__" + set hostname [board_info $board hostname] + set ssh_options [board_info $board ssh,options] + set tmpdir [board_info $board tmpdir] + verbose -log "Closing persistent connection ..." 1 + local_exec "ssh $ssh_options -O exit root@$hostname" {} {} 10 + verbose -log "Cleaning up - executing on board 'rm -fr $tmpdir' ..." 1 + local_exec "ssh -n $ssh_options root@$hostname sh -c 'rm -fr $tmpdir'" \ + {} {} 10 +} + +# +# Upload a file to the board. Uses scp over persistent SSH connection. +# +proc __boardname___download { board file args } { + set hostname [board_info $board hostname] + set tmpdir [board_info $board tmpdir] + set timeout [board_info $board timeout] + set ssh_options [board_info $board ssh,options] + set destfile [lindex [file split $file] end] + verbose -log "scp -q $ssh_options $file root@$hostname:$tmpdir/" + set result [local_exec "scp -q $ssh_options $file root@$hostname:$tmpdir/" \ + {} {} $timeout] + if { [lindex $result 0] != 0 } { + verbose -log "failed to upload \'$file\' to \'$tmpdir/$destfile\'" + } else { + verbose -log "uploaded \"$file\' to remote board@\'$tmpdir/$destfile\'" + return "$tmpdir/$destfile" + } +} + +# +# Download a file to the host machine. Uses scp over persistent SSH connection. +# +proc __boardname___upload { board file args } { + set hostname [board_info $board hostname] + set tmpdir [board_info $board tmpdir] + set timeout [board_info $board timeout] + set ssh_options [board_info $board ssh,options] + set filen [file tail $file] + verbose -log "scp -q $ssh_options \"root@$hostname:$tmpdir/$filen\" ." + set result [local_exec \ + "scp -q $ssh_options \"root@$hostname:$tmpdir/$filen\" ." \ + {} {} $timeout] + if { [lindex $result 0] != 0 } { + verbose -log \ + "failed to transfer \"root@$hostname:$tmpdir/$filen\" to \".\"" + } else { + verbose -log "transferred \"root@$hostname:$tmpdir/$filen\" to \".\"" + # In case of success, always return the original file. + return "$file" + } +} + +# +# Cache program output within different invoking of __boardname___exec. +# For example, the following command sequence will be executed +# > cd /tmp/dejagnu_xxxx/ && ./xxx.x0 +# <output1 here> +# return [0, <output1>] (a) +# > rm /tmp/dejagnu_xxxx/xxxx.x0 +# <output2 here> +# return [0, <output2>] (b) +# We need <output1>, not <output2>. What we do here is to keep <output1> in +# $program_output and in (b) we return [0, <output1>]. +# +set program_output "" + +# +# Execute a test on remote machine. Log into the target machine using +# persistent SSH connection and run a command in modified environment. +# +proc __boardname___exec { board program args } { + global program_output + if { [llength $args] > 0 } { + set pargs [lindex $args 0] + } else { + set pargs "" + } + + if { [llength $args] > 1 } { + set inp "[lindex $args 1]" + } else { + set inp "" + } + + if { [llength $args] > 2 } { + set outp "[lindex $args 2]" + } else { + set outp "" + } + + if { [llength $args] > 3 } { + set timeout "[lindex $args 3]" + } else { + set timeout [board_info $board timeout] + } + + set hostname [board_info $board hostname] + set tmpdir [board_info $board tmpdir] + set other_file "" + + # Check if a file to be executed was copied from host machine. If so, we + # need to run it in copied runtimes. + set is_program "0" + if { [string match "$tmpdir/*" $program] } { + set path [file dirname $program] + # "$program" would usually be like "/x/y/z.out", set command to be "z.out". + set command [file tail $program] + set rootname [file rootname $command] + # TODO(shenhan): using rsync to copy all test case relatd stuff to host + # machine in case ".o" files are different from the exe files. + set other_file [file join $path "${rootname}.*"] + # Change directory to "/x/y", then execute "./z.out" - we want the working + # directory to be "/x/y". Setting GCOV_PREFIX_STRIP and GCOV_PREFIX is to + # force generating ".gcda" file under "/x/y" instead of some host path. + set program "cd $path && GCOV_PREFIX_STRIP=999 GCOV_PREFIX=$tmpdir/ \ + [file join "." $command]" + set is_program "1" + } + verbose -log "Exec: $program" + set ssh_options [board_info $board ssh,options] + set retv [local_exec \ + "ssh -n $ssh_options root@$hostname sh -c '$program $pargs'" \ + $inp $outp $timeout] + set status [lindex $retv 0] + if { $is_program == "1" } { + set program_output [lindex $retv 1] + } + + # Before returning the execution status, we try to transfer the ".gcda" + # (and/or other files that have the same base name as the program) file to + # host, though for every program that runs, there is no corresponding "other" + # file. We have no idea when such an other file will be generated for the + # program, so every time, we assume there is an "other" file and try to do the + # transfer. + if { $status == 0 && $other_file != "" } { + set upv [${board}_upload $board $other_file ""] + if { $upv == "" } { + verbose -log "Safely ignored - \"$other_file\" does not exist." + } + } + + return [list $status $program_output] +} + +load_generic_config "unix" +load_base_board_description "linux-libremote" + +set_board_info hostname "__board_hostname__" +set_board_info tmpdir "__tmp_dir__" + +set_board_info isremote 1 +set_board_info timeout 60 +set_board_info ssh,options "-i __tmp_testing_rsa__ -o ControlMaster=auto \ +-o ControlPath=__tmp_dir__/%r@%h:%p -o StrictHostKeyChecking=no " diff --git a/deprecated/dejagnu/gdb_baseline/armv7a-cros-linux-gnueabi b/deprecated/dejagnu/gdb_baseline/armv7a-cros-linux-gnueabi new file mode 100644 index 00000000..e94a7905 --- /dev/null +++ b/deprecated/dejagnu/gdb_baseline/armv7a-cros-linux-gnueabi @@ -0,0 +1,19079 @@ +Test Run By yunlian on Mon Dec 30 11:13:13 2013 +Target is armv7a-cros-linux-gnueabi + + === gdb tests === + +Schedule of variations: + daisy + +Running target daisy +Running ./gdb.ada/aliased_array.exp ... +UNSUPPORTED: gdb.ada/aliased_array.exp: compilation foo.adb +Running ./gdb.ada/array_bounds.exp ... +UNSUPPORTED: gdb.ada/array_bounds.exp: compilation bar.adb +Running ./gdb.ada/arrayidx.exp ... +UNSUPPORTED: gdb.ada/arrayidx.exp: compilation p.adb +Running ./gdb.ada/arrayparam.exp ... +UNSUPPORTED: gdb.ada/arrayparam.exp: compilation foo.adb +Running ./gdb.ada/arrayptr.exp ... +UNSUPPORTED: gdb.ada/arrayptr.exp: compilation foo.adb +Running ./gdb.ada/array_return.exp ... +UNSUPPORTED: gdb.ada/array_return.exp: compilation p.adb +Running ./gdb.ada/array_subscript_addr.exp ... +UNSUPPORTED: gdb.ada/array_subscript_addr.exp: compilation p.adb +Running ./gdb.ada/assign_1.exp ... +PASS: gdb.ada/assign_1.exp: Changing the language to ada +PASS: gdb.ada/assign_1.exp: set convenience variable $xxx to 1 +Running ./gdb.ada/atomic_enum.exp ... +UNSUPPORTED: gdb.ada/atomic_enum.exp: compilation foo.adb +Running ./gdb.ada/bad-task-bp-keyword.exp ... +UNSUPPORTED: gdb.ada/bad-task-bp-keyword.exp: compilation foo.adb +Running ./gdb.ada/boolean_expr.exp ... +PASS: gdb.ada/boolean_expr.exp: Changing the language to ada +PASS: gdb.ada/boolean_expr.exp: print 1 = 2 +PASS: gdb.ada/boolean_expr.exp: print 3 = 3 +Running ./gdb.ada/bp_enum_homonym.exp ... +UNSUPPORTED: gdb.ada/bp_enum_homonym.exp: compilation p.adb +Running ./gdb.ada/bp_on_var.exp ... +UNSUPPORTED: gdb.ada/bp_on_var.exp: compilation foo.adb +Running ./gdb.ada/bp_range_type.exp ... +UNSUPPORTED: gdb.ada/bp_range_type.exp: compilation foo.adb +Running ./gdb.ada/bp_reset.exp ... +UNSUPPORTED: gdb.ada/bp_reset.exp: compilation foo.adb +Running ./gdb.ada/call_pn.exp ... +UNSUPPORTED: gdb.ada/call_pn.exp: compilation foo.adb +Running ./gdb.ada/catch_ex.exp ... +UNSUPPORTED: gdb.ada/catch_ex.exp: compilation foo.adb +Running ./gdb.ada/char_enum.exp ... +UNSUPPORTED: gdb.ada/char_enum.exp: compilation foo.adb +Running ./gdb.ada/char_param.exp ... +UNSUPPORTED: gdb.ada/char_param.exp: compilation foo.adb +Running ./gdb.ada/complete.exp ... +UNSUPPORTED: gdb.ada/complete.exp: compilation foo.adb +Running ./gdb.ada/cond_lang.exp ... +UNSUPPORTED: gdb.ada/cond_lang.exp: compilation a.adb +Running ./gdb.ada/dyn_loc.exp ... +UNSUPPORTED: gdb.ada/dyn_loc.exp: compilation p.adb +Running ./gdb.ada/enum_idx_packed.exp ... +UNSUPPORTED: gdb.ada/enum_idx_packed.exp: compilation foo.adb +Running ./gdb.ada/exec_changed.exp ... +UNTESTED: gdb.ada/exec_changed.exp: exec_changed.exp +Running ./gdb.ada/expr_delims.exp ... +UNSUPPORTED: gdb.ada/expr_delims.exp: compilation foo.adb +Running ./gdb.ada/exprs.exp ... +UNSUPPORTED: gdb.ada/exprs.exp: compilation p.adb +Running ./gdb.ada/fixed_cmp.exp ... +UNSUPPORTED: gdb.ada/fixed_cmp.exp: compilation fixed.adb +Running ./gdb.ada/fixed_points.exp ... +UNSUPPORTED: gdb.ada/fixed_points.exp: compilation fixed_points.adb +Running ./gdb.ada/formatted_ref.exp ... +UNSUPPORTED: gdb.ada/formatted_ref.exp: compilation formatted_ref.adb +UNTESTED: gdb.ada/formatted_ref.exp: formatted-ref.exp +Running ./gdb.ada/frame_args.exp ... +UNSUPPORTED: gdb.ada/frame_args.exp: compilation foo.adb +Running ./gdb.ada/fullname_bp.exp ... +UNSUPPORTED: gdb.ada/fullname_bp.exp: compilation foo.adb +Running ./gdb.ada/fun_addr.exp ... +UNSUPPORTED: gdb.ada/fun_addr.exp: compilation foo.adb +Running ./gdb.ada/funcall_param.exp ... +UNSUPPORTED: gdb.ada/funcall_param.exp: compilation foo.adb +Running ./gdb.ada/fun_in_declare.exp ... +UNSUPPORTED: gdb.ada/fun_in_declare.exp: compilation foo.adb +Running ./gdb.ada/homonym.exp ... +UNSUPPORTED: gdb.ada/homonym.exp: compilation homonym_main.adb +Running ./gdb.ada/info_locals_renaming.exp ... +UNSUPPORTED: gdb.ada/info_locals_renaming.exp: compilation foo.adb +Running ./gdb.ada/info_types.exp ... +PASS: gdb.ada/info_types.exp: set lang ada +PASS: gdb.ada/info_types.exp: info types new_integer_type +Running ./gdb.ada/int_deref.exp ... +UNSUPPORTED: gdb.ada/int_deref.exp: compilation foo.adb +Running ./gdb.ada/interface.exp ... +UNSUPPORTED: gdb.ada/interface.exp: compilation foo.adb +Running ./gdb.ada/iwide.exp ... +UNSUPPORTED: gdb.ada/iwide.exp: compilation p.adb +Running ./gdb.ada/lang_switch.exp ... +UNSUPPORTED: gdb.ada/lang_switch.exp: compilation lang_switch.adb +Running ./gdb.ada/mi_catch_ex.exp ... +UNSUPPORTED: gdb.ada/mi_catch_ex.exp: compilation foo.adb +Running ./gdb.ada/mi_task_arg.exp ... +UNSUPPORTED: gdb.ada/mi_task_arg.exp: compilation task_switch.adb +Running ./gdb.ada/mi_task_info.exp ... +UNSUPPORTED: gdb.ada/mi_task_info.exp: compilation task_switch.adb +Running ./gdb.ada/mod_from_name.exp ... +UNSUPPORTED: gdb.ada/mod_from_name.exp: compilation foo.adb +Running ./gdb.ada/nested.exp ... +UNSUPPORTED: gdb.ada/nested.exp: compilation hello.adb +Running ./gdb.ada/null_array.exp ... +UNSUPPORTED: gdb.ada/null_array.exp: compilation foo.adb +Running ./gdb.ada/null_record.exp ... +UNSUPPORTED: gdb.ada/null_record.exp: compilation null_record.adb +Running ./gdb.ada/operator_bp.exp ... +UNSUPPORTED: gdb.ada/operator_bp.exp: compilation ops_test.adb +Running ./gdb.ada/optim_drec.exp ... +UNSUPPORTED: gdb.ada/optim_drec.exp: compilation foo.adb +Running ./gdb.ada/packed_array.exp ... +UNSUPPORTED: gdb.ada/packed_array.exp: compilation pa.adb +Running ./gdb.ada/packed_tagged.exp ... +UNSUPPORTED: gdb.ada/packed_tagged.exp: compilation comp_bug.adb +Running ./gdb.ada/print_chars.exp ... +UNSUPPORTED: gdb.ada/print_chars.exp: compilation foo.adb +Running ./gdb.ada/print_pc.exp ... +UNSUPPORTED: gdb.ada/print_pc.exp: compilation dummy.adb +Running ./gdb.ada/ptr_typedef.exp ... +UNSUPPORTED: gdb.ada/ptr_typedef.exp: compilation foo.adb +Running ./gdb.ada/ptype_arith_binop.exp ... +PASS: gdb.ada/ptype_arith_binop.exp: set lang ada +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 * 2.0 +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 / 2.0 +Running ./gdb.ada/ptype_field.exp ... +UNSUPPORTED: gdb.ada/ptype_field.exp: compilation foo.adb +Running ./gdb.ada/ptype_tagged_param.exp ... +UNSUPPORTED: gdb.ada/ptype_tagged_param.exp: compilation foo.adb +Running ./gdb.ada/rdv_wait.exp ... +UNSUPPORTED: gdb.ada/rdv_wait.exp: compilation foo.adb +Running ./gdb.ada/rec_return.exp ... +UNSUPPORTED: gdb.ada/rec_return.exp: compilation foo.adb +Running ./gdb.ada/ref_param.exp ... +UNSUPPORTED: gdb.ada/ref_param.exp: compilation foo.adb +Running ./gdb.ada/ref_tick_size.exp ... +UNSUPPORTED: gdb.ada/ref_tick_size.exp: compilation p.adb +Running ./gdb.ada/same_enum.exp ... +UNSUPPORTED: gdb.ada/same_enum.exp: compilation a.adb +Running ./gdb.ada/set_pckd_arr_elt.exp ... +UNSUPPORTED: gdb.ada/set_pckd_arr_elt.exp: compilation foo.adb +Running ./gdb.ada/set_wstr.exp ... +UNSUPPORTED: gdb.ada/set_wstr.exp: compilation a.adb +Running ./gdb.ada/small_reg_param.exp ... +UNSUPPORTED: gdb.ada/small_reg_param.exp: compilation foo.adb +Running ./gdb.ada/start.exp ... +UNTESTED: gdb.ada/start.exp: start.exp +Running ./gdb.ada/str_ref_cmp.exp ... +UNSUPPORTED: gdb.ada/str_ref_cmp.exp: compilation foo.adb +Running ./gdb.ada/sym_print_name.exp ... +UNSUPPORTED: gdb.ada/sym_print_name.exp: compilation foo.adb +Running ./gdb.ada/taft_type.exp ... +UNSUPPORTED: gdb.ada/taft_type.exp: compilation p.adb +Running ./gdb.ada/tagged.exp ... +UNSUPPORTED: gdb.ada/tagged.exp: compilation foo.adb +Running ./gdb.ada/tagged_not_init.exp ... +UNSUPPORTED: gdb.ada/tagged_not_init.exp: compilation foo.adb +Running ./gdb.ada/task_bp.exp ... +UNSUPPORTED: gdb.ada/task_bp.exp: compilation foo.adb +Running ./gdb.ada/tasks.exp ... +UNSUPPORTED: gdb.ada/tasks.exp: compilation foo.adb +Running ./gdb.ada/tick_last_segv.exp ... +UNSUPPORTED: gdb.ada/tick_last_segv.exp: compilation foo.adb +Running ./gdb.ada/type_coercion.exp ... +UNSUPPORTED: gdb.ada/type_coercion.exp: compilation assign.adb +Running ./gdb.ada/unc_arr_ptr_in_var_rec.exp ... +UNSUPPORTED: gdb.ada/unc_arr_ptr_in_var_rec.exp: compilation foo.adb +Running ./gdb.ada/uninitialized_vars.exp ... +UNSUPPORTED: gdb.ada/uninitialized_vars.exp: compilation parse.adb +Running ./gdb.ada/variant_record_packed_array.exp ... +UNSUPPORTED: gdb.ada/variant_record_packed_array.exp: compilation foo.adb +Running ./gdb.ada/watch_arg.exp ... +UNSUPPORTED: gdb.ada/watch_arg.exp: compilation watch.adb +Running ./gdb.ada/whatis_array_val.exp ... +UNSUPPORTED: gdb.ada/whatis_array_val.exp: compilation foo.adb +Running ./gdb.ada/widewide.exp ... +UNSUPPORTED: gdb.ada/widewide.exp: compilation foo.adb +Running ./gdb.arch/alpha-step.exp ... +Running ./gdb.arch/altivec-abi.exp ... +Running ./gdb.arch/altivec-regs.exp ... +Running ./gdb.arch/amd64-byte.exp ... +Running ./gdb.arch/amd64-disp-step.exp ... +Running ./gdb.arch/amd64-dword.exp ... +Running ./gdb.arch/amd64-entry-value.exp ... +Running ./gdb.arch/amd64-entry-value-inline.exp ... +Running ./gdb.arch/amd64-entry-value-param.exp ... +Running ./gdb.arch/amd64-i386-address.exp ... +Running ./gdb.arch/amd64-prologue-xmm.exp ... +Running ./gdb.arch/amd64-tailcall-cxx.exp ... +Running ./gdb.arch/amd64-tailcall-noret.exp ... +Running ./gdb.arch/amd64-tailcall-ret.exp ... +Running ./gdb.arch/amd64-word.exp ... +Running ./gdb.arch/arm-bl-branch-dest.exp ... +ERROR: tcl error sourcing ./gdb.arch/arm-bl-branch-dest.exp. +ERROR: : spawn id exp7 not open + while executing +"expect_background { + -i $server_spawn_id + full_buffer { } + eof { + # The spawn ID is already closed now (but not yet waited for). + wait -i $exp..." + (procedure "gdbserver_start" line 85) + invoked from within +"gdbserver_start "" $arguments" + (procedure "gdbserver_spawn" line 11) + invoked from within +"gdbserver_spawn $child_args" + (procedure "gdbserver_run" line 20) + invoked from within +"gdbserver_run """ + (procedure "gdb_reload" line 2) + invoked from within +"gdb_reload" + invoked from within +"if [target_info exists gdb,do_reload_on_run] { + if { [gdb_reload] != 0 } { + return; + } + send_gdb "continue\n"; + gdb_expect 60 { + -re..." + invoked from within +"if $use_gdb_stub { + if [target_info exists gdb,do_reload_on_run] { + if { [gdb_reload] != 0 } { + return; + } + send_gdb "continue\n"; + g..." + (procedure "gdb_run_cmd" line 15) + invoked from within +"gdb_run_cmd" + (procedure "runto" line 32) + invoked from within +"runto main no-message" + (procedure "runto_main" line 2) + invoked from within +"runto_main" + invoked from within +"if { ![runto_main] } { + return -1 +}" + (file "./gdb.arch/arm-bl-branch-dest.exp" line 33) + invoked from within +"source ./gdb.arch/arm-bl-branch-dest.exp" + ("uplevel" body line 1) + invoked from within +"uplevel #0 source ./gdb.arch/arm-bl-branch-dest.exp" + invoked from within +"catch "uplevel #0 source $test_file_name"" +Running ./gdb.arch/arm-disp-step.exp ... +PASS: gdb.arch/arm-disp-step.exp: set displaced-stepping off +PASS: gdb.arch/arm-disp-step.exp: set displaced-stepping on +PASS: gdb.arch/arm-disp-step.exp: show displaced-stepping +PASS: gdb.arch/arm-disp-step.exp: break test_call +PASS: gdb.arch/arm-disp-step.exp: break test_call_end +PASS: gdb.arch/arm-disp-step.exp: break test_ret +PASS: gdb.arch/arm-disp-step.exp: break test_ret_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_call +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_call_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_ret +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ret_end +PASS: gdb.arch/arm-disp-step.exp: break test_branch +PASS: gdb.arch/arm-disp-step.exp: break Lbranch +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_branch +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to Lbranch +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_pc +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_pc_ret +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_pc +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_pc_ret +PASS: gdb.arch/arm-disp-step.exp: break test_ldm_stm_pc +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_literal +PASS: gdb.arch/arm-disp-step.exp: break test_ldrsb_literal +PASS: gdb.arch/arm-disp-step.exp: break test_ldrsh_literal +PASS: gdb.arch/arm-disp-step.exp: break test_test_ldr_literal_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_literal +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldrsb_literal +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldrsh_literal +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_literal_ret +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_literal +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_literal_16_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_literal_16 +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_ldr_literal_16_end +PASS: gdb.arch/arm-disp-step.exp: break test_ldr_literal +PASS: gdb.arch/arm-disp-step.exp: break test_zero_cbz +PASS: gdb.arch/arm-disp-step.exp: break test_non_zero_cbnz +PASS: gdb.arch/arm-disp-step.exp: break test_non_zero_cbz +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_zero_cbnz +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_zero_cbz +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_non_zero_cbz +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_non_zero_cbnz +PASS: gdb.arch/arm-disp-step.exp: break test_adr +PASS: gdb.arch/arm-disp-step.exp: break test_adr_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_adr +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_adr_end +PASS: gdb.arch/arm-disp-step.exp: break test_adr +PASS: gdb.arch/arm-disp-step.exp: break test_adr_32bit_after +PASS: gdb.arch/arm-disp-step.exp: break test_adr_32bit_end +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_adr_32bit +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_adr_32bit_after +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: test_adr_32bit_end +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_1 +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_2 +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_3 +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_ret +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_1_right +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_1_wrong +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_2_right +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_2_wrong +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_3_right +PASS: gdb.arch/arm-disp-step.exp: break test_pop_pc_1_wrong +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_1 +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_1_check +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_2 +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_2_check +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_3 +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_3_check +PASS: gdb.arch/arm-disp-step.exp: continue to breakpoint: continue to test_pop_pc_ret +PASS: gdb.arch/arm-disp-step.exp: break test_str_pc +FAIL: gdb.arch/arm-disp-step.exp: setting breakpoint at exit +Running ./gdb.arch/e500-abi.exp ... +Running ./gdb.arch/e500-prologue.exp ... +Running ./gdb.arch/e500-regs.exp ... +Running ./gdb.arch/gdb1291.exp ... +Running ./gdb.arch/gdb1431.exp ... +Running ./gdb.arch/gdb1558.exp ... +Running ./gdb.arch/i386-avx.exp ... +Running ./gdb.arch/i386-bp_permanent.exp ... +Running ./gdb.arch/i386-byte.exp ... +Running ./gdb.arch/i386-cfi-notcurrent.exp ... +Running ./gdb.arch/i386-disp-step.exp ... +Running ./gdb.arch/i386-dr3-watch.exp ... +Running ./gdb.arch/i386-float.exp ... +Running ./gdb.arch/i386-gnu-cfi.exp ... +Running ./gdb.arch/i386-permbkpt.exp ... +Running ./gdb.arch/i386-prologue.exp ... +Running ./gdb.arch/i386-signal.exp ... +Running ./gdb.arch/i386-size.exp ... +Running ./gdb.arch/i386-size-overlap.exp ... +Running ./gdb.arch/i386-sse.exp ... +Running ./gdb.arch/i386-sse-stack-align.exp ... +Running ./gdb.arch/i386-unwind.exp ... +Running ./gdb.arch/i386-word.exp ... +Running ./gdb.arch/ia64-breakpoint-shadow.exp ... +Running ./gdb.arch/iwmmxt-regs.exp ... +Running ./gdb.arch/mips16-thunks.exp ... +Running ./gdb.arch/mips-octeon-bbit.exp ... +Running ./gdb.arch/pa-nullify.exp ... +Running ./gdb.arch/powerpc-aix-prologue.exp ... +Running ./gdb.arch/powerpc-d128-regs.exp ... +Running ./gdb.arch/powerpc-prologue.exp ... +Running ./gdb.arch/ppc64-atomic-inst.exp ... +Running ./gdb.arch/ppc-dfp.exp ... +Running ./gdb.arch/ppc-fp.exp ... +Running ./gdb.arch/spu-info.exp ... +Running ./gdb.arch/spu-ls.exp ... +Running ./gdb.arch/system-gcore.exp ... +Running ./gdb.arch/thumb2-it.exp ... +PASS: gdb.arch/thumb2-it.exp: list main +PASS: gdb.arch/thumb2-it.exp: it_1, call +PASS: gdb.arch/thumb2-it.exp: it_1, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_1, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_1, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_1, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_1, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_1, continue +PASS: gdb.arch/thumb2-it.exp: it_2, call +PASS: gdb.arch/thumb2-it.exp: it_2, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_2, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_2, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_2, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_2, $r0 == 0 +PASS: gdb.arch/thumb2-it.exp: it_2, continue +PASS: gdb.arch/thumb2-it.exp: it_3, call +PASS: gdb.arch/thumb2-it.exp: it_3, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_3, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_3, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_3, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_3, stepi 4 +PASS: gdb.arch/thumb2-it.exp: it_3, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_3, $r0 == 5 +PASS: gdb.arch/thumb2-it.exp: it_3, continue +PASS: gdb.arch/thumb2-it.exp: it_4, call +PASS: gdb.arch/thumb2-it.exp: it_4, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_4, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_4, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_4, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_4, stepi 4 +PASS: gdb.arch/thumb2-it.exp: it_4, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_4, $r0 == 1 +PASS: gdb.arch/thumb2-it.exp: it_4, continue +PASS: gdb.arch/thumb2-it.exp: it_5, call +PASS: gdb.arch/thumb2-it.exp: it_5, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_5, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_5, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_5, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_5, stepi 4 +PASS: gdb.arch/thumb2-it.exp: it_5, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_5, $r0 == 1 +PASS: gdb.arch/thumb2-it.exp: it_5, continue +PASS: gdb.arch/thumb2-it.exp: it_6, call +PASS: gdb.arch/thumb2-it.exp: it_6, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_6, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_6, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_6, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_6, stepi 4 +PASS: gdb.arch/thumb2-it.exp: it_6, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_6, $r0 == 3 +PASS: gdb.arch/thumb2-it.exp: it_6, continue +PASS: gdb.arch/thumb2-it.exp: it_7, call +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 4 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 5 +PASS: gdb.arch/thumb2-it.exp: it_7, stepi 6 +PASS: gdb.arch/thumb2-it.exp: it_7, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_7, $r0 == 15 +PASS: gdb.arch/thumb2-it.exp: it_7, continue +PASS: gdb.arch/thumb2-it.exp: it_8, call +PASS: gdb.arch/thumb2-it.exp: it_8, stepi 0 +PASS: gdb.arch/thumb2-it.exp: it_8, stepi 1 +PASS: gdb.arch/thumb2-it.exp: it_8, stepi 2 +PASS: gdb.arch/thumb2-it.exp: it_8, stepi 3 +PASS: gdb.arch/thumb2-it.exp: it_8, correct instructions reached +PASS: gdb.arch/thumb2-it.exp: it_8, $r0 == 1 +PASS: gdb.arch/thumb2-it.exp: it_8, continue +PASS: gdb.arch/thumb2-it.exp: call it_breakpoints() +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 1 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 2 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 3 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 4 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 5 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 6 +PASS: gdb.arch/thumb2-it.exp: continue to breakpoint: test 7 +Running ./gdb.arch/thumb-bx-pc.exp ... +PASS: gdb.arch/thumb-bx-pc.exp: stepi for bx pc +PASS: gdb.arch/thumb-bx-pc.exp: stepi reached correct instruction +Running ./gdb.arch/thumb-prologue.exp ... +PASS: gdb.arch/thumb-prologue.exp: continue to TPCS +PASS: gdb.arch/thumb-prologue.exp: backtrace in TPCS +PASS: gdb.arch/thumb-prologue.exp: saved registers in TPCS +PASS: gdb.arch/thumb-prologue.exp: continue to switch_stack_to_same +PASS: gdb.arch/thumb-prologue.exp: stepi over mov sp, sp +PASS: gdb.arch/thumb-prologue.exp: backtrace in write_sp +PASS: gdb.arch/thumb-prologue.exp: continue to switch_stack_to_other +PASS: gdb.arch/thumb-prologue.exp: stepi over mov sp, 128 +PASS: gdb.arch/thumb-prologue.exp: backtrace in write_sp +Running ./gdb.arch/thumb-singlestep.exp ... +PASS: gdb.arch/thumb-singlestep.exp: step into foo +Running ./gdb.arch/vsx-regs.exp ... +Running ./gdb.asm/asm-source.exp ... +PASS: gdb.asm/asm-source.exp: f at main +PASS: gdb.asm/asm-source.exp: next over macro +PASS: gdb.asm/asm-source.exp: step into foo2 +PASS: gdb.asm/asm-source.exp: info target +PASS: gdb.asm/asm-source.exp: info symbol +PASS: gdb.asm/asm-source.exp: list +PASS: gdb.asm/asm-source.exp: search +PASS: gdb.asm/asm-source.exp: f in foo2 +PASS: gdb.asm/asm-source.exp: n in foo2 +PASS: gdb.asm/asm-source.exp: bt ALL in foo2 +PASS: gdb.asm/asm-source.exp: bt 2 in foo2 +PASS: gdb.asm/asm-source.exp: s 2 +PASS: gdb.asm/asm-source.exp: n 2 +PASS: gdb.asm/asm-source.exp: bt 3 in foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc1.s +PASS: gdb.asm/asm-source.exp: finish from foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc2.s +PASS: gdb.asm/asm-source.exp: info sources +PASS: gdb.asm/asm-source.exp: info line +PASS: gdb.asm/asm-source.exp: next over foo3 +PASS: gdb.asm/asm-source.exp: return from foo2 +PASS: gdb.asm/asm-source.exp: look at global variable +PASS: gdb.asm/asm-source.exp: x/i &globalvar +PASS: gdb.asm/asm-source.exp: disassem &globalvar, &globalvar+1 +PASS: gdb.asm/asm-source.exp: look at static variable +PASS: gdb.asm/asm-source.exp: x/i &staticvar +PASS: gdb.asm/asm-source.exp: disassem &staticvar, &staticvar+1 +PASS: gdb.asm/asm-source.exp: look at static function +Running ./gdb.base/a2-run.exp ... +Running ./gdb.base/advance.exp ... +PASS: gdb.base/advance.exp: advance line number +PASS: gdb.base/advance.exp: malformed advance +PASS: gdb.base/advance.exp: advance func +PASS: gdb.base/advance.exp: advance function not called by current frame +PASS: gdb.base/advance.exp: set breakpoint at call to func3 +PASS: gdb.base/advance.exp: continue to call to func3 in main +PASS: gdb.base/advance.exp: advance function called as param +PASS: gdb.base/advance.exp: advance with no argument +Running ./gdb.base/alias.exp ... +PASS: gdb.base/alias.exp: alias -a set2=set +PASS: gdb.base/alias.exp: set2 print elements 42 +PASS: gdb.base/alias.exp: verify set2 +PASS: gdb.base/alias.exp: abbrev set2 not present in help command list +PASS: gdb.base/alias.exp: alias -a set3= set +PASS: gdb.base/alias.exp: set3 print elements 43 +PASS: gdb.base/alias.exp: verify set3 +PASS: gdb.base/alias.exp: abbrev set3 not present in help command list +PASS: gdb.base/alias.exp: alias -a set4 =set +PASS: gdb.base/alias.exp: set4 print elements 44 +PASS: gdb.base/alias.exp: verify set4 +PASS: gdb.base/alias.exp: abbrev set4 not present in help command list +PASS: gdb.base/alias.exp: alias -a set5 = set +PASS: gdb.base/alias.exp: set5 print elements 45 +PASS: gdb.base/alias.exp: verify set5 +PASS: gdb.base/alias.exp: abbrev set5 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- set6 = set +PASS: gdb.base/alias.exp: set6 print elements 46 +PASS: gdb.base/alias.exp: verify set6 +PASS: gdb.base/alias.exp: abbrev set6 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- -a = set +PASS: gdb.base/alias.exp: -a print elements 47 +PASS: gdb.base/alias.exp: verify -a +PASS: gdb.base/alias.exp: abbrev -a not present in help command list +PASS: gdb.base/alias.exp: alias set2=set +PASS: gdb.base/alias.exp: alias foo=bar +PASS: gdb.base/alias.exp: alias spe = set p elem +PASS: gdb.base/alias.exp: spe 50 +PASS: gdb.base/alias.exp: verify spe +PASS: gdb.base/alias.exp: alias set pr elms = set p elem +PASS: gdb.base/alias.exp: set pr elms 51 +PASS: gdb.base/alias.exp: verify set pr elms +PASS: gdb.base/alias.exp: help set print +Running ./gdb.base/all-bin.exp ... +PASS: gdb.base/all-bin.exp: continuing after dummy() +PASS: gdb.base/all-bin.exp: print value of v_int+v_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_float +PASS: gdb.base/all-bin.exp: print value of v_int+v_double +PASS: gdb.base/all-bin.exp: print value of v_int<=v_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_float +PASS: gdb.base/all-bin.exp: print value of v_int<=v_double +PASS: gdb.base/all-bin.exp: set v_char=0 +PASS: gdb.base/all-bin.exp: set v_double=0 +PASS: gdb.base/all-bin.exp: set v_unsigned_long=0 +PASS: gdb.base/all-bin.exp: print value of v_int&&v_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_float +PASS: gdb.base/all-bin.exp: print value of v_int&&v_double +Running ./gdb.base/annota1.exp ... +Running ./gdb.base/annota3.exp ... +Running ./gdb.base/anon.exp ... +PASS: gdb.base/anon.exp: set breakpoint in anon.c +PASS: gdb.base/anon.exp: continue to breakpoint: continue to breakpoint in anon.c +PASS: gdb.base/anon.exp: print val.data.six +Running ./gdb.base/args.exp ... +Running ./gdb.base/argv0-symlink.exp ... +PASS: gdb.base/argv0-symlink.exp: kept file symbolic link name +FAIL: gdb.base/argv0-symlink.exp: kept directory symbolic link name +Running ./gdb.base/arithmet.exp ... +PASS: gdb.base/arithmet.exp: set variable x=14 +PASS: gdb.base/arithmet.exp: set variable y=2 +PASS: gdb.base/arithmet.exp: set variable z=2 +PASS: gdb.base/arithmet.exp: set variable w=3 +PASS: gdb.base/arithmet.exp: print x +PASS: gdb.base/arithmet.exp: print y +PASS: gdb.base/arithmet.exp: print z +PASS: gdb.base/arithmet.exp: print w +PASS: gdb.base/arithmet.exp: print x+y +PASS: gdb.base/arithmet.exp: print x-y +PASS: gdb.base/arithmet.exp: print x*y +PASS: gdb.base/arithmet.exp: print x/y +PASS: gdb.base/arithmet.exp: print x%y +PASS: gdb.base/arithmet.exp: print x+y+z +PASS: gdb.base/arithmet.exp: print x-y-z +PASS: gdb.base/arithmet.exp: print x*y*z +PASS: gdb.base/arithmet.exp: print x/y/z +PASS: gdb.base/arithmet.exp: print x%y%z +PASS: gdb.base/arithmet.exp: set variable x=10 +PASS: gdb.base/arithmet.exp: set variable y=4 +PASS: gdb.base/arithmet.exp: print x+y-z +PASS: gdb.base/arithmet.exp: print x+y*z +PASS: gdb.base/arithmet.exp: print x+y%w +PASS: gdb.base/arithmet.exp: print x+y/w +PASS: gdb.base/arithmet.exp: print x-y*z +PASS: gdb.base/arithmet.exp: print x-y%z +PASS: gdb.base/arithmet.exp: print x-y/z +PASS: gdb.base/arithmet.exp: print x*y/z +PASS: gdb.base/arithmet.exp: print x*y%w +PASS: gdb.base/arithmet.exp: print x/y%w +PASS: gdb.base/arithmet.exp: print x-(y+w) +PASS: gdb.base/arithmet.exp: print x/(y*w) +PASS: gdb.base/arithmet.exp: print x-(y/w) +PASS: gdb.base/arithmet.exp: print (x+y)*w +Running ./gdb.base/arrayidx.exp ... +PASS: gdb.base/arrayidx.exp: Set print array-indexes to off +PASS: gdb.base/arrayidx.exp: Print array with array-indexes off +PASS: gdb.base/arrayidx.exp: Set print array-indexes to on +PASS: gdb.base/arrayidx.exp: Print array with array-indexes on +Running ./gdb.base/assign.exp ... +PASS: gdb.base/assign.exp: continuing after dummy() +PASS: gdb.base/assign.exp: v_int=57 +PASS: gdb.base/assign.exp: set v_int to 6 +PASS: gdb.base/assign.exp: v_int+=57 +PASS: gdb.base/assign.exp: set v_int to 6 (2) +PASS: gdb.base/assign.exp: v_int-=57 +PASS: gdb.base/assign.exp: set v_int to 6 (3) +PASS: gdb.base/assign.exp: v_int*=5 +PASS: gdb.base/assign.exp: set v_int to 6 (4) +PASS: gdb.base/assign.exp: v_int/=4 +PASS: gdb.base/assign.exp: set v_int to 6 (5) +PASS: gdb.base/assign.exp: v_int%=4 +PASS: gdb.base/assign.exp: set v_int to 6 (6) +PASS: gdb.base/assign.exp: v_int+=char +PASS: gdb.base/assign.exp: set v_int to 6 (7) +PASS: gdb.base/assign.exp: v_int+=signed_char +PASS: gdb.base/assign.exp: set v_int to 6 (8) +PASS: gdb.base/assign.exp: v_int+=unsigned_char +PASS: gdb.base/assign.exp: set v_int to 6 (9) +PASS: gdb.base/assign.exp: v_int+=short +PASS: gdb.base/assign.exp: set v_int to 6 (10) +PASS: gdb.base/assign.exp: v_int+=signed_short +PASS: gdb.base/assign.exp: set v_int to 6 (11) +PASS: gdb.base/assign.exp: v_int=+unsigned_short +PASS: gdb.base/assign.exp: set v_int to 6 (12) +PASS: gdb.base/assign.exp: v_int+=signed_int +PASS: gdb.base/assign.exp: set v_int to 6 (13) +PASS: gdb.base/assign.exp: v_int+=unsigned_int +PASS: gdb.base/assign.exp: set v_int to 6 (14) +PASS: gdb.base/assign.exp: v_int+=long +PASS: gdb.base/assign.exp: set v_int to 6 (15) +PASS: gdb.base/assign.exp: v_int+=signed_long +PASS: gdb.base/assign.exp: set v_int to 6 (16) +PASS: gdb.base/assign.exp: v_int+=unsigned_long +PASS: gdb.base/assign.exp: set v_int to 6 (17) +PASS: gdb.base/assign.exp: v_int+=v_float +PASS: gdb.base/assign.exp: set v_int to 6 (18) +PASS: gdb.base/assign.exp: v_int+=double +Running ./gdb.base/async.exp ... +Running ./gdb.base/async-shell.exp ... +Running ./gdb.base/attach.exp ... +Running ./gdb.base/attach-pie-misread.exp ... +Running ./gdb.base/attach-pie-noexec.exp ... +Running ./gdb.base/attach-twice.exp ... +Running ./gdb.base/auxv.exp ... +PASS: gdb.base/auxv.exp: set print sevenbit-strings +PASS: gdb.base/auxv.exp: set width 0 +PASS: gdb.base/auxv.exp: tbreak 78 +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: info auxv on live process +PASS: gdb.base/auxv.exp: gcore +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: continue +UNSUPPORTED: gdb.base/auxv.exp: generate native core dump +UNSUPPORTED: gdb.base/auxv.exp: info auxv on native core dump +UNSUPPORTED: gdb.base/auxv.exp: matching auxv data from live and core +PASS: gdb.base/auxv.exp: load core file for info auxv on gcore-created dump +PASS: gdb.base/auxv.exp: info auxv on gcore-created dump +PASS: gdb.base/auxv.exp: matching auxv data from live and gcore +Running ./gdb.base/bang.exp ... +PASS: gdb.base/bang.exp: run program +Running ./gdb.base/bfp-test.exp ... +PASS: gdb.base/bfp-test.exp: continue to breakpoint: return +PASS: gdb.base/bfp-test.exp: The original value of b32 is 1.5 +PASS: gdb.base/bfp-test.exp: The original value of b64 is 2.25 +PASS: gdb.base/bfp-test.exp: The original value of b128 is 3.375 +PASS: gdb.base/bfp-test.exp: Try to change b32 to -1.5 with 'print b32=-1.5f' +PASS: gdb.base/bfp-test.exp: Try to change b64 to -2.25 with 'print b64=-2.25f' +PASS: gdb.base/bfp-test.exp: Try to change b128 to -3.375 with 'print b128=-3.375l' +PASS: gdb.base/bfp-test.exp: set variable b32 = 10.5f +PASS: gdb.base/bfp-test.exp: set variable b64 = 20.25f +PASS: gdb.base/bfp-test.exp: set variable b128 = 30.375l +PASS: gdb.base/bfp-test.exp: The value of b32 is changed to 10.5 +PASS: gdb.base/bfp-test.exp: The value of b64 is changed to 20.25 +PASS: gdb.base/bfp-test.exp: The value of b128 is changed to 30.375 +PASS: gdb.base/bfp-test.exp: set variable b32 = 100.5a +PASS: gdb.base/bfp-test.exp: set variable b64 = 200.25x +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fl +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fff +Running ./gdb.base/bigcore.exp ... +UNTESTED: gdb.base/bigcore.exp: Remote system +Running ./gdb.base/bitfields2.exp ... +PASS: gdb.base/bitfields2.exp: set print sevenbit-strings +PASS: gdb.base/bitfields2.exp: break tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #0 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #1 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #2 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #3 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #4 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s3 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #5 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u3 = 1 +PASS: gdb.base/bitfields2.exp: break tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to break2 #0 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u1, flags.u3, and flags.s3 to all 1s +PASS: gdb.base/bitfields2.exp: continuing to break2 #1 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u2, flags.s1, flags.s2 to all 1s +PASS: gdb.base/bitfields2.exp: break tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to break3 #0 +PASS: gdb.base/bitfields2.exp: maximum unsigned bitfield values +PASS: gdb.base/bitfields2.exp: break tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to break4 #0 +PASS: gdb.base/bitfields2.exp: maximum signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #1 +PASS: gdb.base/bitfields2.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields2.exp: most negative signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #2 +PASS: gdb.base/bitfields2.exp: signed bitfields containing -1 +PASS: gdb.base/bitfields2.exp: break tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to break5 #0 +PASS: gdb.base/bitfields2.exp: set long long unsigned bitfield +PASS: gdb.base/bitfields2.exp: set long long signed bitfield positive +PASS: gdb.base/bitfields2.exp: long long bitfield values after set +PASS: gdb.base/bitfields2.exp: set long long signed bitfield negative +PASS: gdb.base/bitfields2.exp: long long bitfield values after set negative +Running ./gdb.base/bitfields.exp ... +PASS: gdb.base/bitfields.exp: set print sevenbit-strings +PASS: gdb.base/bitfields.exp: print flags +PASS: gdb.base/bitfields.exp: continuing to break1 #1 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s1) +PASS: gdb.base/bitfields.exp: continuing to break1 #2 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u1) +PASS: gdb.base/bitfields.exp: continuing to break1 #3 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s2) +PASS: gdb.base/bitfields.exp: continuing to break1 #4 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u2) +PASS: gdb.base/bitfields.exp: continuing to break1 #5 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s3) +PASS: gdb.base/bitfields.exp: continuing to break1 #6 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u3) +PASS: gdb.base/bitfields.exp: continuing to break1 #7 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s9) +PASS: gdb.base/bitfields.exp: continuing to break1 #8 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u9) +PASS: gdb.base/bitfields.exp: continuing to break1 #9 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (sc) +PASS: gdb.base/bitfields.exp: bitfield containment #1 +PASS: gdb.base/bitfields.exp: continuing to break2 +PASS: gdb.base/bitfields.exp: bitfield containment #2 +PASS: gdb.base/bitfields.exp: unsigned bitfield ranges +PASS: gdb.base/bitfields.exp: signed bitfields, max positive values +PASS: gdb.base/bitfields.exp: continuing to break4 #1 +PASS: gdb.base/bitfields.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields.exp: signed bitfields, max negative values +PASS: gdb.base/bitfields.exp: continuing to break4 #2 +PASS: gdb.base/bitfields.exp: signed bitfields with -1 +PASS: gdb.base/bitfields.exp: continuing to break5 +PASS: gdb.base/bitfields.exp: distinct bitfields in container +PASS: gdb.base/bitfields.exp: print container.one.u3 +PASS: gdb.base/bitfields.exp: print container.two.u3 +PASS: gdb.base/bitfields.exp: set internal var +PASS: gdb.base/bitfields.exp: set $myvar.a = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.b = 1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.c = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.d = -1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.e = 1 +PASS: gdb.base/bitfields.exp: set $myvar.f = 1 +PASS: gdb.base/bitfields.exp: print $myvar.a +PASS: gdb.base/bitfields.exp: print $myvar.inner.b +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.c +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.d +PASS: gdb.base/bitfields.exp: print $myvar.inner.e +PASS: gdb.base/bitfields.exp: print $myvar.f +Running ./gdb.base/bitops.exp ... +PASS: gdb.base/bitops.exp: print value of !1 +PASS: gdb.base/bitops.exp: print value of !0 +PASS: gdb.base/bitops.exp: print value of !100 +PASS: gdb.base/bitops.exp: print value of !1000 +PASS: gdb.base/bitops.exp: print value of !10 +PASS: gdb.base/bitops.exp: print value of !2 +PASS: gdb.base/bitops.exp: print value of 10 | 5 +PASS: gdb.base/bitops.exp: print value of 10 & 5 +PASS: gdb.base/bitops.exp: print value of 10 ^ 5 +PASS: gdb.base/bitops.exp: print value of -!0 +PASS: gdb.base/bitops.exp: print value of ~-!0 +PASS: gdb.base/bitops.exp: print value of 3 * 2 / 4.0 * 2.0 +PASS: gdb.base/bitops.exp: print value of 8 << 2 >> 4 +PASS: gdb.base/bitops.exp: print value of -1 < 0 > 1 +PASS: gdb.base/bitops.exp: print value of 15 ^ 10 ^ 5 ^ 7 +PASS: gdb.base/bitops.exp: print value of 3.5 < 4.0 +PASS: gdb.base/bitops.exp: print value of 3.5 < -4.0 +PASS: gdb.base/bitops.exp: print value of 2 > -3 +PASS: gdb.base/bitops.exp: print value of -3>4 +PASS: gdb.base/bitops.exp: print value of (-3 > 4) +PASS: gdb.base/bitops.exp: print value of 3>=2.5 +PASS: gdb.base/bitops.exp: print value of 3>=4.5 +PASS: gdb.base/bitops.exp: print value of 3==3.0 +PASS: gdb.base/bitops.exp: print value of 3==4.0 +PASS: gdb.base/bitops.exp: print value of 3!=3.0 +PASS: gdb.base/bitops.exp: print value of 3!=5.0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 > 128 >>1 +2 *2 +PASS: gdb.base/bitops.exp: print value of 1.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 1.0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 +PASS: gdb.base/bitops.exp: print value of 0 == 8 > 128 >> 1 + 2 * 2 +Running ./gdb.base/break-always.exp ... +PASS: gdb.base/break-always.exp: set breakpoint always-inserted on +PASS: gdb.base/break-always.exp: confirm breakpoint always-inserted +PASS: gdb.base/break-always.exp: set breakpoint on bar +PASS: gdb.base/break-always.exp: set 2nd breakpoint on bar +PASS: gdb.base/break-always.exp: set 3rd breakpoint on bar +PASS: gdb.base/break-always.exp: set 4th breakpoint on bar +PASS: gdb.base/break-always.exp: initial check breakpoint state +PASS: gdb.base/break-always.exp: initial disable all breakpoints +PASS: gdb.base/break-always.exp: initial enable all breakpoints +PASS: gdb.base/break-always.exp: re-disable all breakpoints +PASS: gdb.base/break-always.exp: enable 3.A +PASS: gdb.base/break-always.exp: disable 3.B +PASS: gdb.base/break-always.exp: enable 3.C +PASS: gdb.base/break-always.exp: enable 2.D +PASS: gdb.base/break-always.exp: disable 2.E +PASS: gdb.base/break-always.exp: disable 3.F +PASS: gdb.base/break-always.exp: enable 3.G +PASS: gdb.base/break-always.exp: enable 2.H +PASS: gdb.base/break-always.exp: disable 2.I +PASS: gdb.base/break-always.exp: before re-enable check breakpoint state +PASS: gdb.base/break-always.exp: re-enable all breakpoints +PASS: gdb.base/break-always.exp: set breakpoint on bar 2 +PASS: gdb.base/break-always.exp: save shadow +PASS: gdb.base/break-always.exp: write 0 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 0 from the breakpoint's address +PASS: gdb.base/break-always.exp: write 1 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 1 from the breakpoint's address +PASS: gdb.base/break-always.exp: p /x *(char *) 0x54aaa69c = $shadow +PASS: gdb.base/break-always.exp: continue to breakpoint: bar +Running ./gdb.base/break-caller-line.exp ... +PASS: gdb.base/break-caller-line.exp: up +PASS: gdb.base/break-caller-line.exp: info line *$pc +PASS: gdb.base/break-caller-line.exp: break +Running ./gdb.base/break-entry.exp ... +UNTESTED: gdb.base/break-entry.exp: break-entry.exp +Running ./gdb.base/break.exp ... +PASS: gdb.base/break.exp: Delete all breakpoints when none +PASS: gdb.base/break.exp: breakpoint function +PASS: gdb.base/break.exp: breakpoint quoted function +PASS: gdb.base/break.exp: breakpoint function in file +PASS: gdb.base/break.exp: use `list' to establish default source file +PASS: gdb.base/break.exp: breakpoint line number +PASS: gdb.base/break.exp: breakpoint duplicate +PASS: gdb.base/break.exp: breakpoint line number in file +PASS: gdb.base/break.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/break.exp: breakpoint at start of multi line while conditional +FAIL: gdb.base/break.exp: breakpoint info +PASS: gdb.base/break.exp: info break 2 4 6 +PASS: gdb.base/break.exp: info break 3-5 +PASS: gdb.base/break.exp: disable using history values +FAIL: gdb.base/break.exp: check disable with history values +PASS: gdb.base/break.exp: disable with convenience values +FAIL: gdb.base/break.exp: check disable with convenience values +PASS: gdb.base/break.exp: disable non-existent breakpoint 10 +PASS: gdb.base/break.exp: set $baz 1.234 +PASS: gdb.base/break.exp: disable with non-integer convenience var +PASS: gdb.base/break.exp: disable with non-existent convenience var +PASS: gdb.base/break.exp: disable with non-existent history value +PASS: gdb.base/break.exp: disable with badly formed history value +FAIL: gdb.base/break.exp: run until function breakpoint +PASS: gdb.base/break.exp: list marker1 +PASS: gdb.base/break.exp: break lineno +PASS: gdb.base/break.exp: delete $bpnum +PASS: gdb.base/break.exp: run until breakpoint set at a line number +PASS: gdb.base/break.exp: run until file:function(6) breakpoint +PASS: gdb.base/break.exp: run until file:function(5) breakpoint +PASS: gdb.base/break.exp: run until file:function(4) breakpoint +PASS: gdb.base/break.exp: run until file:function(3) breakpoint +PASS: gdb.base/break.exp: run until file:function(2) breakpoint +PASS: gdb.base/break.exp: run until file:function(1) breakpoint +PASS: gdb.base/break.exp: run until quoted breakpoint +PASS: gdb.base/break.exp: run until file:linenum breakpoint +PASS: gdb.base/break.exp: breakpoint offset +1 +PASS: gdb.base/break.exp: step onto breakpoint +PASS: gdb.base/break.exp: setting breakpoint at } +PASS: gdb.base/break.exp: continue to breakpoint at } +PASS: gdb.base/break.exp: Temporary breakpoint function +PASS: gdb.base/break.exp: Temporary breakpoint function in file +PASS: gdb.base/break.exp: Temporary breakpoint line number #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number #2 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #2 +FAIL: gdb.base/break.exp: Temporary breakpoint info +PASS: gdb.base/break.exp: catch requires an event name +PASS: gdb.base/break.exp: set catch fork, never expected to trigger +PASS: gdb.base/break.exp: set catch vfork, never expected to trigger +PASS: gdb.base/break.exp: set catch exec, never expected to trigger +PASS: gdb.base/break.exp: set breakpoint pending off +PASS: gdb.base/break.exp: break on non-existent source line +PASS: gdb.base/break.exp: until bp_location1 +PASS: gdb.base/break.exp: break on default location, 1st time +PASS: gdb.base/break.exp: break on default location, 2nd time +PASS: gdb.base/break.exp: break on default location, 3rd time +PASS: gdb.base/break.exp: break on default location, 4th time +PASS: gdb.base/break.exp: set to-be-silent break bp_location1 +PASS: gdb.base/break.exp: set silent break bp_location1 +PASS: gdb.base/break.exp: info silent break bp_location1 +PASS: gdb.base/break.exp: hit silent break bp_location1 +PASS: gdb.base/break.exp: stopped for silent break bp_location1 +PASS: gdb.base/break.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/break.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/break.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/break.exp: step over breakpoint +PASS: gdb.base/break.exp: clear line has no breakpoint disallowed +PASS: gdb.base/break.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/break.exp: break marker3 #1 +PASS: gdb.base/break.exp: break marker3 #2 +PASS: gdb.base/break.exp: clear marker3 +PASS: gdb.base/break.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/break.exp: set breakpoint via convenience variable +PASS: gdb.base/break.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/break.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/break.exp: set breakpoint on to-be-called function +PASS: gdb.base/break.exp: hit breakpoint on called function +PASS: gdb.base/break.exp: backtrace while in called function +PASS: gdb.base/break.exp: finish from called function +PASS: gdb.base/break.exp: finish with arguments disallowed +PASS: gdb.base/break.exp: finish from outermost frame disallowed +PASS: gdb.base/break.exp: kill program +PASS: gdb.base/break.exp: break at factorial +PASS: gdb.base/break.exp: continue to factorial(5) +PASS: gdb.base/break.exp: backtrace from factorial(5) +PASS: gdb.base/break.exp: next to recursive call +PASS: gdb.base/break.exp: next over recursive call +PASS: gdb.base/break.exp: backtrace from factorial(5.1) +FAIL: gdb.base/break.exp: setting breakpoint at exit +PASS: gdb.base/break.exp: breakpoint function, optimized file +PASS: gdb.base/break.exp: breakpoint small function, optimized file +PASS: gdb.base/break.exp: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/break.exp: run until breakpoint set at small function, optimized file +PASS: gdb.base/break.exp: rbreak junk pending setup +PASS: gdb.base/break.exp: rbreak junk set breakpoint +PASS: gdb.base/break.exp: rbreak junk +Running ./gdb.base/break-inline.exp ... +PASS: gdb.base/break-inline.exp: break +Running ./gdb.base/break-interp.exp ... +Running ./gdb.base/break-on-linker-gcd-function.exp ... +PASS: gdb.base/break-on-linker-gcd-function.exp: b 25 +Running ./gdb.base/breakpoint-shadow.exp ... +PASS: gdb.base/breakpoint-shadow.exp: set breakpoint always-inserted on +PASS: gdb.base/breakpoint-shadow.exp: show breakpoint always-inserted +PASS: gdb.base/breakpoint-shadow.exp: disassembly without breakpoints +PASS: gdb.base/breakpoint-shadow.exp: First breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: Second breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: disassembly with breakpoints +Running ./gdb.base/call-ar-st.exp ... +PASS: gdb.base/call-ar-st.exp: set print sevenbit-strings +PASS: gdb.base/call-ar-st.exp: set print address off +PASS: gdb.base/call-ar-st.exp: set width 0 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1209 +PASS: gdb.base/call-ar-st.exp: run until breakpoint set at a line +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1216 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1220 +PASS: gdb.base/call-ar-st.exp: step inside print_all_arrays +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1236 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1241 +PASS: gdb.base/call-ar-st.exp: continue to 1241 +PASS: gdb.base/call-ar-st.exp: set breakpoint in sum_array_print +PASS: gdb.base/call-ar-st.exp: set print frame-arguments all +PASS: gdb.base/call-ar-st.exp: check args of sum_array_print +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1281 +PASS: gdb.base/call-ar-st.exp: print compute_with_small_structs(20) +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1286 +PASS: gdb.base/call-ar-st.exp: continue to 1286 +PASS: gdb.base/call-ar-st.exp: tbreak in print_long_arg_list after stepping into memcpy +PASS: gdb.base/call-ar-st.exp: step into print_long_arg_list +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1300 +PASS: gdb.base/call-ar-st.exp: step into init_bit_flags_combo +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1305 +PASS: gdb.base/call-ar-st.exp: continue to 1305 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1311 +PASS: gdb.base/call-ar-st.exp: continue to 1311 +Running ./gdb.base/callexit.exp ... +PASS: gdb.base/callexit.exp: inferior function call terminated program +Running ./gdb.base/callfuncs.exp ... +PASS: gdb.base/callfuncs.exp: set print sevenbit-strings +PASS: gdb.base/callfuncs.exp: set print address off +PASS: gdb.base/callfuncs.exp: set width 0 +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: set unwindonsignal on +PASS: gdb.base/callfuncs.exp: p t_char_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_char_values('a','b') +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values('a',char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,'b') +PASS: gdb.base/callfuncs.exp: p t_short_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,-23) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,-23) +PASS: gdb.base/callfuncs.exp: p t_int_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,-26) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,-26) +PASS: gdb.base/callfuncs.exp: p t_long_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,-321) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,-321) +PASS: gdb.base/callfuncs.exp: p t_float_values(0.0,0.0) +FAIL: gdb.base/callfuncs.exp: p t_float_values(3.14159,-2.3765) +FAIL: gdb.base/callfuncs.exp: p t_float_values(float_val1,float_val2) +FAIL: gdb.base/callfuncs.exp: p t_float_values(3.14159,float_val2) +FAIL: gdb.base/callfuncs.exp: p t_float_values(float_val1,-2.3765) +PASS: gdb.base/callfuncs.exp: p t_float_values2(0.0,0.0) +FAIL: gdb.base/callfuncs.exp: p t_float_values2(3.14159,float_val2) +FAIL: gdb.base/callfuncs.exp: Call function with many float arguments. +PASS: gdb.base/callfuncs.exp: p t_small_values(1,2,3,4,5,6,7,8,9,10) +PASS: gdb.base/callfuncs.exp: p t_double_values(0.0,0.0) +FAIL: gdb.base/callfuncs.exp: p t_double_values(45.654,-67.66) +FAIL: gdb.base/callfuncs.exp: p t_double_values(double_val1,double_val2) +FAIL: gdb.base/callfuncs.exp: p t_double_values(45.654,double_val2) +FAIL: gdb.base/callfuncs.exp: p t_double_values(double_val1,-67.66) +FAIL: gdb.base/callfuncs.exp: Call function with many double arguments. +FAIL: gdb.base/callfuncs.exp: p t_double_int(99.0, 1) +FAIL: gdb.base/callfuncs.exp: p t_double_int(99.0, 99) +FAIL: gdb.base/callfuncs.exp: p t_int_double(99, 1.0) +FAIL: gdb.base/callfuncs.exp: p t_int_double(99, 99.0) +FAIL: gdb.base/callfuncs.exp: p t_float_complex_values(fc1, fc2) +PASS: gdb.base/callfuncs.exp: p t_float_complex_values(fc3, fc4) +FAIL: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4) +PASS: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1) +FAIL: gdb.base/callfuncs.exp: p t_double_complex_values(dc1, dc2) +PASS: gdb.base/callfuncs.exp: p t_double_complex_values(dc3, dc4) +FAIL: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4) +PASS: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1) +FAIL: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc1, ldc2) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc3, ldc4) +FAIL: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1,ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val2,string_val1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val1,string_val2) +FAIL: gdb.base/callfuncs.exp: p t_string_values("string 1","string 2") +FAIL: gdb.base/callfuncs.exp: p t_string_values("string 1",string_val2) +FAIL: gdb.base/callfuncs.exp: p t_string_values(string_val1,"string 2") +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val2,char_array_val1) +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,char_array_val2) +FAIL: gdb.base/callfuncs.exp: p t_char_array_values("carray 1","carray 2") +FAIL: gdb.base/callfuncs.exp: p t_char_array_values("carray 1",char_array_val2) +FAIL: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,"carray 2") +PASS: gdb.base/callfuncs.exp: p doubleit(4) +PASS: gdb.base/callfuncs.exp: p add(4,5) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val2,func_val1) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,func_val2) +PASS: gdb.base/callfuncs.exp: p function_struct.func(5) +PASS: gdb.base/callfuncs.exp: p function_struct_ptr->func(10) +PASS: gdb.base/callfuncs.exp: p t_func_values(add,func_val2) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,doubleit) +PASS: gdb.base/callfuncs.exp: p t_call_add(add,3,4) +PASS: gdb.base/callfuncs.exp: p t_call_add(func_val1,3,4) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enumval1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enumval2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val1) +FAIL: gdb.base/callfuncs.exp: p sum_args(1,{2}) +FAIL: gdb.base/callfuncs.exp: p sum_args(2,{2,3}) +FAIL: gdb.base/callfuncs.exp: p sum_args(3,{2,3,4}) +FAIL: gdb.base/callfuncs.exp: p sum_args(4,{2,3,4,5}) +PASS: gdb.base/callfuncs.exp: p sum10 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) +PASS: gdb.base/callfuncs.exp: p cmp10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns short +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns int +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns float +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns double +FAIL: gdb.base/callfuncs.exp: call inferior func with struct - returns float _Complex +FAIL: gdb.base/callfuncs.exp: call inferior func with struct - returns double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char * +PASS: gdb.base/callfuncs.exp: set unwindonsignal off +PASS: gdb.base/callfuncs.exp: register contents after gdb function calls +PASS: gdb.base/callfuncs.exp: gdb function calls preserve register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at breakpoint in call dummy function +PASS: gdb.base/callfuncs.exp: continue from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: bt after continuing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after stop in call dummy +PASS: gdb.base/callfuncs.exp: continue after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint then do a finish +PASS: gdb.base/callfuncs.exp: finish from call dummy breakpoint returns correct value +PASS: gdb.base/callfuncs.exp: bt after finishing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after finish in call dummy +PASS: gdb.base/callfuncs.exp: finish after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint and then do a return +PASS: gdb.base/callfuncs.exp: back at main after return from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after return in call dummy +PASS: gdb.base/callfuncs.exp: return after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 1 +PASS: gdb.base/callfuncs.exp: stop at nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 2 +PASS: gdb.base/callfuncs.exp: stop at nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 3 +PASS: gdb.base/callfuncs.exp: stop at nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: register contents after nested call dummies +PASS: gdb.base/callfuncs.exp: nested call dummies preserve register contents +PASS: gdb.base/callfuncs.exp: set $old_sp = $sp +PASS: gdb.base/callfuncs.exp: set $sp = 0 +PASS: gdb.base/callfuncs.exp: sp == 0: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = -1 +PASS: gdb.base/callfuncs.exp: sp == -1: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = $old_sp +PASS: gdb.base/callfuncs.exp: print callfunc (Lcallfunc, 5) +PASS: gdb.base/callfuncs.exp: print *((int *(*) (void)) voidfunc)() +Running ./gdb.base/call-rt-st.exp ... +PASS: gdb.base/call-rt-st.exp: set print sevenbit-strings +PASS: gdb.base/call-rt-st.exp: set print address off +PASS: gdb.base/call-rt-st.exp: set width 0 +PASS: gdb.base/call-rt-st.exp: breakpoint loop_count +PASS: gdb.base/call-rt-st.exp: continue to loop_count +PASS: gdb.base/call-rt-st.exp: finish out from loop_count (line 777) +Running ./gdb.base/call-sc.exp ... +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tc (char) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tc char +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tc +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tc +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tc +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tc +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ts (short int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ts short int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ts +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ts +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ts +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ts +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ti (int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ti int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ti +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ti +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ti +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ti +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tl (long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tl long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tl +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tl +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tl +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tl +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tll (long long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tll long long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tll +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tll +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tll +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tll +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tf (float) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tf float +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tf +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tf +FAIL: gdb.base/call-sc.exp: p/c L; call call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +FAIL: gdb.base/call-sc.exp: value foo returned; return call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tf +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tf +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-td (double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-td double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-td +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-td +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-td +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-td +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-td +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tld (long double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tld long double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tld +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tld +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tld +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tld +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-te (enum {e = 49}) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-te enum {e = 49} +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-te +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-te +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-te +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-te +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-te +Running ./gdb.base/call-signal-resume.exp ... +Running ./gdb.base/call-strs.exp ... +PASS: gdb.base/call-strs.exp: set print sevenbit-strings +PASS: gdb.base/call-strs.exp: set print address off +PASS: gdb.base/call-strs.exp: set print symbol off +PASS: gdb.base/call-strs.exp: set width 0 +FAIL: gdb.base/call-strs.exp: step after assignment to s +FAIL: gdb.base/call-strs.exp: next over strcpy +FAIL: gdb.base/call-strs.exp: print buf +FAIL: gdb.base/call-strs.exp: print s +Running ./gdb.base/catch-load.exp ... +FAIL: gdb.base/catch-load.exp: plain load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain load: catch load +FAIL: gdb.base/catch-load.exp: plain load: continue +FAIL: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: catch load +FAIL: gdb.base/catch-load.exp: plain load with stop-on-solib-events: continue +FAIL: gdb.base/catch-load.exp: rx load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx load: catch load catch-load-so +FAIL: gdb.base/catch-load.exp: rx load: continue +FAIL: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: catch load catch-load-so +FAIL: gdb.base/catch-load.exp: rx load with stop-on-solib-events: continue +FAIL: gdb.base/catch-load.exp: non-matching load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching load: catch load zardoz +FAIL: gdb.base/catch-load.exp: non-matching load: continue +FAIL: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: catch load zardoz +FAIL: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: continue +FAIL: gdb.base/catch-load.exp: plain unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain unload: catch unload +FAIL: gdb.base/catch-load.exp: plain unload: continue +FAIL: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: catch unload +FAIL: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: continue +FAIL: gdb.base/catch-load.exp: rx unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx unload: catch unload catch-load-so +FAIL: gdb.base/catch-load.exp: rx unload: continue +FAIL: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: catch unload catch-load-so +FAIL: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: continue +FAIL: gdb.base/catch-load.exp: non-matching unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching unload: catch unload zardoz +FAIL: gdb.base/catch-load.exp: non-matching unload: continue +FAIL: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: catch unload zardoz +FAIL: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: continue +Running ./gdb.base/catch-signal.exp ... +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGHUP +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: 1: catch signal 1 +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGHUP SIGUSR2 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: catch signal SIGZARDOZ +PASS: gdb.base/catch-signal.exp: catch signal all +PASS: gdb.base/catch-signal.exp: catch signal all SIGHUP +PASS: gdb.base/catch-signal.exp: catch signal SIGHUP all +PASS: gdb.base/catch-signal.exp: set catchpoint '' for printing +PASS: gdb.base/catch-signal.exp: info break for '' +PASS: gdb.base/catch-signal.exp: save breakpoints for '' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for '' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP SIGUSR2' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: set catchpoint 'all' for printing +PASS: gdb.base/catch-signal.exp: info break for 'all' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'all' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'all' +Running ./gdb.base/catch-syscall.exp ... +Running ./gdb.base/charset.exp ... +PASS: gdb.base/charset.exp: show charset +PASS: gdb.base/charset.exp: show target-charset +PASS: gdb.base/charset.exp: check `show target-charset' against `show charset' +PASS: gdb.base/charset.exp: show host-charset +PASS: gdb.base/charset.exp: check `show host-charset' against `show charset' +PASS: gdb.base/charset.exp: try malformed `set charset' +PASS: gdb.base/charset.exp: try `set host-charset' with invalid charset +PASS: gdb.base/charset.exp: try `set target-charset' with invalid charset +PASS: gdb.base/charset.exp: capture valid host charsets +PASS: gdb.base/charset.exp: capture valid target charsets +PASS: gdb.base/charset.exp: try `set host-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set host-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set host-charset IBM1047' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: set breakpoint after all strings have been initialized +PASS: gdb.base/charset.exp: run until all strings have been initialized +PASS: gdb.base/charset.exp: get integer valueof "sizeof (wchar_t)" (4) +PASS: gdb.base/charset.exp: set host-charset ASCII +PASS: gdb.base/charset.exp: set target-charset ASCII +PASS: gdb.base/charset.exp: print the null character in ASCII +PASS: gdb.base/charset.exp: print string in ASCII +PASS: gdb.base/charset.exp: parse character literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed character literal in ASCII +PASS: gdb.base/charset.exp: parse string literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed string literal in ASCII +PASS: gdb.base/charset.exp: try printing '\a' in ASCII +PASS: gdb.base/charset.exp: check value of '\a' in ASCII +PASS: gdb.base/charset.exp: check value of "\a" in ASCII +PASS: gdb.base/charset.exp: try printing '\b' in ASCII +PASS: gdb.base/charset.exp: check value of '\b' in ASCII +PASS: gdb.base/charset.exp: check value of "\b" in ASCII +PASS: gdb.base/charset.exp: try printing '\f' in ASCII +PASS: gdb.base/charset.exp: check value of '\f' in ASCII +PASS: gdb.base/charset.exp: check value of "\f" in ASCII +PASS: gdb.base/charset.exp: try printing '\n' in ASCII +PASS: gdb.base/charset.exp: check value of '\n' in ASCII +PASS: gdb.base/charset.exp: check value of "\n" in ASCII +PASS: gdb.base/charset.exp: try printing '\r' in ASCII +PASS: gdb.base/charset.exp: check value of '\r' in ASCII +PASS: gdb.base/charset.exp: check value of "\r" in ASCII +PASS: gdb.base/charset.exp: try printing '\t' in ASCII +PASS: gdb.base/charset.exp: check value of '\t' in ASCII +PASS: gdb.base/charset.exp: check value of "\t" in ASCII +PASS: gdb.base/charset.exp: try printing '\v' in ASCII +PASS: gdb.base/charset.exp: check value of '\v' in ASCII +PASS: gdb.base/charset.exp: check value of "\v" in ASCII +PASS: gdb.base/charset.exp: print escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: set target-charset ISO-8859-1 +PASS: gdb.base/charset.exp: print the null character in ISO-8859-1 +PASS: gdb.base/charset.exp: print string in ISO-8859-1 +PASS: gdb.base/charset.exp: parse character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: parse string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\a" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\b" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\f" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\n" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\r" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\t" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\v" in ISO-8859-1 +PASS: gdb.base/charset.exp: print escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: set target-charset EBCDIC-US +PASS: gdb.base/charset.exp: print the null character in EBCDIC-US +PASS: gdb.base/charset.exp: print string in EBCDIC-US +PASS: gdb.base/charset.exp: parse character literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed character literal in EBCDIC-US +PASS: gdb.base/charset.exp: parse string literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed string literal in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\a" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\b" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\f" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\n" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\r" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\t" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\v" in EBCDIC-US +PASS: gdb.base/charset.exp: print escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: set target-charset IBM1047 +PASS: gdb.base/charset.exp: print the null character in IBM1047 +PASS: gdb.base/charset.exp: print string in IBM1047 +PASS: gdb.base/charset.exp: parse character literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed character literal in IBM1047 +PASS: gdb.base/charset.exp: parse string literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed string literal in IBM1047 +PASS: gdb.base/charset.exp: try printing '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\a" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\b" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\f" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\n" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\r" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\t" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\v" in IBM1047 +PASS: gdb.base/charset.exp: print escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: set target-wide-charset UTF-32 +PASS: gdb.base/charset.exp: print the null character in UTF-32 +PASS: gdb.base/charset.exp: print string in UTF-32 +PASS: gdb.base/charset.exp: parse character literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed character literal in UTF-32 +PASS: gdb.base/charset.exp: parse string literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed string literal in UTF-32 +PASS: gdb.base/charset.exp: try printing '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\a" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\b" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\f" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\n" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\r" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\t" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\v" in UTF-32 +PASS: gdb.base/charset.exp: print escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: set target-charset UTF-8 +PASS: gdb.base/charset.exp: non-representable target character +PASS: gdb.base/charset.exp: print '\x' +PASS: gdb.base/charset.exp: print '\u' +PASS: gdb.base/charset.exp: print '\9' +PASS: gdb.base/charset.exp: print "\1011" +PASS: gdb.base/charset.exp: basic wide string concatenation +PASS: gdb.base/charset.exp: narrow and wide string concatenation +PASS: gdb.base/charset.exp: wide and narrow string concatenation +PASS: gdb.base/charset.exp: wide string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty wide string +PASS: gdb.base/charset.exp: basic wide character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char16_t)" (2) +PASS: gdb.base/charset.exp: basic UTF-16 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-16 string concatenation +PASS: gdb.base/charset.exp: UTF-16 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-16 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-16 string +PASS: gdb.base/charset.exp: basic UTF-16 character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char32_t)" (4) +PASS: gdb.base/charset.exp: basic UTF-32 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-32 string concatenation +PASS: gdb.base/charset.exp: UTF-32 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-32 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-32 string +PASS: gdb.base/charset.exp: basic UTF-32 character +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-16 +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-32 +PASS: gdb.base/charset.exp: typedef to wchar_t +PASS: gdb.base/charset.exp: undefined concatenation of UTF-16 and UTF-32 +PASS: gdb.base/charset.exp: set up for python printing of utf-16 string +PASS: gdb.base/charset.exp: extract utf-16 string using python +PASS: gdb.base/charset.exp: EVAL_SKIP cleanup handling regression test +FAIL: gdb.base/charset.exp: Assign String16 with prefix u +FAIL: gdb.base/charset.exp: Display String String16 with x/hs +FAIL: gdb.base/charset.exp: Assign String32 with prefix U +FAIL: gdb.base/charset.exp: Display String String32 with x/ws +FAIL: gdb.base/charset.exp: Assign String32 with prefix L +FAIL: gdb.base/charset.exp: Display String String32 with x/ws +PASS: gdb.base/charset.exp: assign string to short array +PASS: gdb.base/charset.exp: assign string to int array +PASS: gdb.base/charset.exp: assign string to long array +Running ./gdb.base/checkpoint.exp ... +Running ./gdb.base/chng-syms.exp ... +PASS: gdb.base/chng-syms.exp: setting conditional breakpoint on function +FAIL: gdb.base/chng-syms.exp: setting breakpoint at exit +PASS: gdb.base/chng-syms.exp: running with invalidated bpt condition after executable changes +Running ./gdb.base/code_elim.exp ... +PASS: gdb.base/code_elim.exp: symbol-file code_elim1 +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single psymtabs: get address of main +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single symtabs: get address of main +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order1: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_global_func +PASS: gdb.base/code_elim.exp: order1: get address of main +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order2: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_global_func +PASS: gdb.base/code_elim.exp: order2: get address of main +Running ./gdb.base/code-expr.exp ... +PASS: gdb.base/code-expr.exp: set print sevenbit-strings +PASS: gdb.base/code-expr.exp: set print address off +PASS: gdb.base/code-expr.exp: set width 0 +PASS: gdb.base/code-expr.exp: (@code char) +PASS: gdb.base/code-expr.exp: (@code signed char) +PASS: gdb.base/code-expr.exp: (@code unsigned char) +PASS: gdb.base/code-expr.exp: (@code short) +PASS: gdb.base/code-expr.exp: (@code signed short) +PASS: gdb.base/code-expr.exp: (@code unsigned short) +PASS: gdb.base/code-expr.exp: (@code int) +PASS: gdb.base/code-expr.exp: (@code signed int) +PASS: gdb.base/code-expr.exp: (@code unsigned int) +PASS: gdb.base/code-expr.exp: (@code long) +PASS: gdb.base/code-expr.exp: (@code signed long) +PASS: gdb.base/code-expr.exp: (@code unsigned long) +PASS: gdb.base/code-expr.exp: (@code long long) +PASS: gdb.base/code-expr.exp: (@code signed long long) +PASS: gdb.base/code-expr.exp: (@code unsigned long long) +PASS: gdb.base/code-expr.exp: (@code float) +PASS: gdb.base/code-expr.exp: (@code double) +PASS: gdb.base/code-expr.exp: (@data char) +PASS: gdb.base/code-expr.exp: (@data signed char) +PASS: gdb.base/code-expr.exp: (@data unsigned char) +PASS: gdb.base/code-expr.exp: (@data short) +PASS: gdb.base/code-expr.exp: (@data signed short) +PASS: gdb.base/code-expr.exp: (@data unsigned short) +PASS: gdb.base/code-expr.exp: (@data int) +PASS: gdb.base/code-expr.exp: (@data signed int) +PASS: gdb.base/code-expr.exp: (@data unsigned int) +PASS: gdb.base/code-expr.exp: (@data long) +PASS: gdb.base/code-expr.exp: (@data signed long) +PASS: gdb.base/code-expr.exp: (@data unsigned long) +PASS: gdb.base/code-expr.exp: (@data long long) +PASS: gdb.base/code-expr.exp: (@data signed long long) +PASS: gdb.base/code-expr.exp: (@data unsigned long long) +PASS: gdb.base/code-expr.exp: (@data float) +PASS: gdb.base/code-expr.exp: (@data double) +PASS: gdb.base/code-expr.exp: (char @code) +PASS: gdb.base/code-expr.exp: (signed char @code) +PASS: gdb.base/code-expr.exp: (unsigned char @code) +PASS: gdb.base/code-expr.exp: (short @code) +PASS: gdb.base/code-expr.exp: (signed short @code) +PASS: gdb.base/code-expr.exp: (unsigned short @code) +PASS: gdb.base/code-expr.exp: (int @code) +PASS: gdb.base/code-expr.exp: (signed int @code) +PASS: gdb.base/code-expr.exp: (unsigned int @code) +PASS: gdb.base/code-expr.exp: (long @code) +PASS: gdb.base/code-expr.exp: (signed long @code) +PASS: gdb.base/code-expr.exp: (unsigned long @code) +PASS: gdb.base/code-expr.exp: (long long @code) +PASS: gdb.base/code-expr.exp: (signed long long @code) +PASS: gdb.base/code-expr.exp: (unsigned long long @code) +PASS: gdb.base/code-expr.exp: (float @code) +PASS: gdb.base/code-expr.exp: (double @code) +PASS: gdb.base/code-expr.exp: (char @data) +PASS: gdb.base/code-expr.exp: (signed char @data) +PASS: gdb.base/code-expr.exp: (unsigned char @data) +PASS: gdb.base/code-expr.exp: (short @data) +PASS: gdb.base/code-expr.exp: (signed short @data) +PASS: gdb.base/code-expr.exp: (unsigned short @data) +PASS: gdb.base/code-expr.exp: (int @data) +PASS: gdb.base/code-expr.exp: (signed int @data) +PASS: gdb.base/code-expr.exp: (unsigned int @data) +PASS: gdb.base/code-expr.exp: (long @data) +PASS: gdb.base/code-expr.exp: (signed long @data) +PASS: gdb.base/code-expr.exp: (unsigned long @data) +PASS: gdb.base/code-expr.exp: (long long @data) +PASS: gdb.base/code-expr.exp: (signed long long @data) +PASS: gdb.base/code-expr.exp: (unsigned long long @data) +PASS: gdb.base/code-expr.exp: (float @data) +PASS: gdb.base/code-expr.exp: (double @data) +PASS: gdb.base/code-expr.exp: (@code enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @code) +PASS: gdb.base/code-expr.exp: (@data enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @data) +PASS: gdb.base/code-expr.exp: (@code int *) +PASS: gdb.base/code-expr.exp: (int @code *) +PASS: gdb.base/code-expr.exp: (int * @code) +PASS: gdb.base/code-expr.exp: (@code int * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code) +PASS: gdb.base/code-expr.exp: (@code int **) +PASS: gdb.base/code-expr.exp: (int @code **) +PASS: gdb.base/code-expr.exp: (int ** @code) +PASS: gdb.base/code-expr.exp: (@code int * @code *) +PASS: gdb.base/code-expr.exp: (int @code * @code *) +PASS: gdb.base/code-expr.exp: (@code int * @code * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct) +PASS: gdb.base/code-expr.exp: (@code union t_union) +PASS: gdb.base/code-expr.exp: (struct t_struct @code) +PASS: gdb.base/code-expr.exp: (union t_union @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct *) +PASS: gdb.base/code-expr.exp: (@code union t_union *) +PASS: gdb.base/code-expr.exp: (struct t_struct @code *) +PASS: gdb.base/code-expr.exp: (union t_union @code *) +PASS: gdb.base/code-expr.exp: (struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (union t_union * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (@code union t_union * @code) +PASS: gdb.base/code-expr.exp: (struct t_struct @code * @code) +PASS: gdb.base/code-expr.exp: (union t_union @code * @code) +Running ./gdb.base/commands.exp ... +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_if_test +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #1 +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #2 +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_while_test +PASS: gdb.base/commands.exp: gdbvar_simple_while_test #1 +PASS: gdb.base/commands.exp: set foo in gdbvar complex_if_while_test +PASS: gdb.base/commands.exp: gdbvar_complex_if_while_test #1 +PASS: gdb.base/commands.exp: set foo in user_defined_command_test +PASS: gdb.base/commands.exp: define mycommand in user_defined_command_test +PASS: gdb.base/commands.exp: enter commands in user_defined_command_test +PASS: gdb.base/commands.exp: execute user defined command in user_defined_command_test +PASS: gdb.base/commands.exp: display user command in user_defined_command_test +PASS: gdb.base/commands.exp: tried to deprecate non-existing command +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /1/ +PASS: gdb.base/commands.exp: p deprecated warning, with replacement +PASS: gdb.base/commands.exp: Deprecated warning goes away /1/ +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /2/ +PASS: gdb.base/commands.exp: maintenance deprecate print "new_print" +PASS: gdb.base/commands.exp: both alias and command are deprecated +PASS: gdb.base/commands.exp: Deprecated warning goes away /2/ +PASS: gdb.base/commands.exp: deprecate long command /1/ +PASS: gdb.base/commands.exp: long command deprecated /1/ +PASS: gdb.base/commands.exp: deprecate long command /2/ +PASS: gdb.base/commands.exp: long command deprecated with no alternative /2/ +PASS: gdb.base/commands.exp: deprecate with no arguments +PASS: gdb.base/commands.exp: stray_arg0_test #1 +PASS: gdb.base/commands.exp: stray_arg0_test #2 +PASS: gdb.base/commands.exp: stray_arg0_test #3 +PASS: gdb.base/commands.exp: stray_arg0_test #4 +PASS: gdb.base/commands.exp: source file with indented comment +PASS: gdb.base/commands.exp: recursive source test +PASS: gdb.base/commands.exp: set $tem in if_commands_test +PASS: gdb.base/commands.exp: if $tem == 2 - if_commands_test 1 +PASS: gdb.base/commands.exp: break main - if_commands_test 1 +PASS: gdb.base/commands.exp: else - if_commands_test 1 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 1 +PASS: gdb.base/commands.exp: commands - if_commands_test 1 +PASS: gdb.base/commands.exp: silent - if_commands_test 1 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 1 +PASS: gdb.base/commands.exp: continue - if_commands_test 1 +PASS: gdb.base/commands.exp: first end - if_commands_test 1 +PASS: gdb.base/commands.exp: second end - if_commands_test 1 +PASS: gdb.base/commands.exp: if $tem == 1 - if_commands_test 2 +PASS: gdb.base/commands.exp: break main - if_commands_test 2 +PASS: gdb.base/commands.exp: else - if_commands_test 2 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 2 +PASS: gdb.base/commands.exp: commands - if_commands_test 2 +PASS: gdb.base/commands.exp: silent - if_commands_test 2 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 2 +PASS: gdb.base/commands.exp: continue - if_commands_test 2 +PASS: gdb.base/commands.exp: first end - if_commands_test 2 +PASS: gdb.base/commands.exp: second end - if_commands_test 2 +PASS: gdb.base/commands.exp: hook-stop 1 +PASS: gdb.base/commands.exp: hook-stop 1a +PASS: gdb.base/commands.exp: hook-stop 1b +PASS: gdb.base/commands.exp: main commands 1 +PASS: gdb.base/commands.exp: main commands 1a +PASS: gdb.base/commands.exp: main commands 1b +PASS: gdb.base/commands.exp: main commands 1c +PASS: gdb.base/commands.exp: main commands 2 +PASS: gdb.base/commands.exp: main commands 2a +PASS: gdb.base/commands.exp: main commands 2b +PASS: gdb.base/commands.exp: main commands 2c +PASS: gdb.base/commands.exp: cmd1 error +PASS: gdb.base/commands.exp: no cmd2 +PASS: gdb.base/commands.exp: define one +PASS: gdb.base/commands.exp: define hook-one +PASS: gdb.base/commands.exp: define one in redefine_hook_test +PASS: gdb.base/commands.exp: enter commands for one redefinition in redefine_hook_test +PASS: gdb.base/commands.exp: execute one command in redefine_hook_test +PASS: gdb.base/commands.exp: define backtrace +PASS: gdb.base/commands.exp: expect response to define backtrace +PASS: gdb.base/commands.exp: enter commands in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute backtrace command in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute bt command in redefine_backtrace_test +Running ./gdb.base/completion.exp ... +PASS: gdb.base/completion.exp: complete 'hfgfh' +PASS: gdb.base/completion.exp: complete 'show output' +PASS: gdb.base/completion.exp: complete 'show output-' +PASS: gdb.base/completion.exp: complete 'p' +PASS: gdb.base/completion.exp: complete 'p ' +PASS: gdb.base/completion.exp: complete 'info t foo' +PASS: gdb.base/completion.exp: complete 'info t' +PASS: gdb.base/completion.exp: complete 'info t ' +PASS: gdb.base/completion.exp: complete 'info asdfgh' +PASS: gdb.base/completion.exp: complete 'info asdfgh ' +PASS: gdb.base/completion.exp: complete 'info' +PASS: gdb.base/completion.exp: complete 'info ' +PASS: gdb.base/completion.exp: complete (2) 'info ' +PASS: gdb.base/completion.exp: complete 'help info wat' +PASS: gdb.base/completion.exp: complete 'p "break1' +XFAIL: gdb.base/completion.exp: complete 'p "break1.' +PASS: gdb.base/completion.exp: complete 'p 'arg' +PASS: gdb.base/completion.exp: complete (2) 'p 'arg' +PASS: gdb.base/completion.exp: complete 'handle signal' +PASS: gdb.base/completion.exp: complete 'handle keyword' +PASS: gdb.base/completion.exp: complete help aliases +PASS: gdb.base/completion.exp: complete 'p no_var_named_this-arg' +PASS: gdb.base/completion.exp: complete (2) 'p no_var_named_this-arg' +FAIL: gdb.base/completion.exp: complete (2) 'p no_var_named_this-' (timeout) +FAIL: gdb.base/completion.exp: complete 'p values[0].a' (timeout) +FAIL: gdb.base/completion.exp: complete 'p values[0] . a' (timeout) +FAIL: gdb.base/completion.exp: complete 'p &values[0] -> a' (timeout) +FAIL: gdb.base/completion.exp: completion of field in anonymous union +FAIL: gdb.base/completion.exp: ptype completion of field in anonymous union +PASS: gdb.base/completion.exp: whatis completion of field in anonymous union +PASS: gdb.base/completion.exp: cd to ${srcdir} +PASS: gdb.base/completion.exp: directory completion +PASS: gdb.base/completion.exp: directory completion 2 +PASS: gdb.base/completion.exp: Glob remaining of directory test +PASS: gdb.base/completion.exp: complete-command 'file ./gdb.base/compl' +PASS: gdb.base/completion.exp: complete 'file ./gdb.base/complet' +PASS: gdb.base/completion.exp: complete 'info func marke' +PASS: gdb.base/completion.exp: complete 'set follow-fork-mode' +PASS: gdb.base/completion.exp: field completion with invalid field +PASS: gdb.base/completion.exp: test non-deprecated completion +PASS: gdb.base/completion.exp: test deprecated completion +PASS: gdb.base/completion.exp: complete ptype struct some_ +PASS: gdb.base/completion.exp: complete ptype enum some_ +PASS: gdb.base/completion.exp: complete ptype union some_ +PASS: gdb.base/completion.exp: complete set gnutarget aut +PASS: gdb.base/completion.exp: complete set cp-abi aut +Running ./gdb.base/complex.exp ... +PASS: gdb.base/complex.exp: print complex packed value in C +PASS: gdb.base/complex.exp: print complex value in C +Running ./gdb.base/comprdebug.exp ... +PASS: gdb.base/comprdebug.exp: file comprdebug0.o +Running ./gdb.base/condbreak.exp ... +PASS: gdb.base/condbreak.exp: breakpoint function +PASS: gdb.base/condbreak.exp: break marker1 if 1==1 +PASS: gdb.base/condbreak.exp: delete 2 +PASS: gdb.base/condbreak.exp: break break.c:92 if 1==1 +PASS: gdb.base/condbreak.exp: delete 3 +PASS: gdb.base/condbreak.exp: break marker1 if (1==1) +PASS: gdb.base/condbreak.exp: break break.c:92 if (1==1) +PASS: gdb.base/condbreak.exp: break marker2 if (a==43) +PASS: gdb.base/condbreak.exp: break marker3 if (multi_line_if_conditional(1,1,1)==0) +PASS: gdb.base/condbreak.exp: break marker4 +FAIL: gdb.base/condbreak.exp: breakpoint info +PASS: gdb.base/condbreak.exp: rerun to main +PASS: gdb.base/condbreak.exp: run until breakpoint set at a line number +PASS: gdb.base/condbreak.exp: run until breakpoint at marker1 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker2 +PASS: gdb.base/condbreak.exp: break main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break *main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) task 999 +PASS: gdb.base/condbreak.exp: break *main task 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) t 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) th 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) ta 999 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker3 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker4 +PASS: gdb.base/condbreak.exp: complete cond 1 +PASS: gdb.base/condbreak.exp: set variable $var = 1 +PASS: gdb.base/condbreak.exp: complete cond $v +PASS: gdb.base/condbreak.exp: complete cond 1 values[0].a +Running ./gdb.base/cond-eval-mode.exp ... +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation host +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation auto +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation target +Running ./gdb.base/cond-expr.exp ... +PASS: gdb.base/cond-expr.exp: print value of cond expr (const true) +PASS: gdb.base/cond-expr.exp: print value of cond expr (const false) +PASS: gdb.base/cond-expr.exp: set variable x=14 +PASS: gdb.base/cond-expr.exp: set variable y=2 +PASS: gdb.base/cond-expr.exp: set variable z=3 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var true) +PASS: gdb.base/cond-expr.exp: set variable x=0 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var false) +PASS: gdb.base/cond-expr.exp: print whatis of cond expr +Running ./gdb.base/consecutive.exp ... +PASS: gdb.base/consecutive.exp: continue to breakpoint in foo +PASS: gdb.base/consecutive.exp: get breakpoint address for foo +PASS: gdb.base/consecutive.exp: set bp, 2nd instr +PASS: gdb.base/consecutive.exp: stopped at bp, 2nd instr +Running ./gdb.base/constvars.exp ... +PASS: gdb.base/constvars.exp: break marker1 +PASS: gdb.base/constvars.exp: continue to marker1 +PASS: gdb.base/constvars.exp: up from marker1 +PASS: gdb.base/constvars.exp: ptype qux1 +PASS: gdb.base/constvars.exp: print lave +PASS: gdb.base/constvars.exp: ptype lave +PASS: gdb.base/constvars.exp: print lavish +PASS: gdb.base/constvars.exp: ptype lavish +PASS: gdb.base/constvars.exp: print lax +PASS: gdb.base/constvars.exp: ptype lax +PASS: gdb.base/constvars.exp: print lecherous +PASS: gdb.base/constvars.exp: ptype lecherous +PASS: gdb.base/constvars.exp: print lechery +PASS: gdb.base/constvars.exp: ptype lechery +PASS: gdb.base/constvars.exp: print lectern +PASS: gdb.base/constvars.exp: ptype lectern +PASS: gdb.base/constvars.exp: print leeway +PASS: gdb.base/constvars.exp: ptype leeway +PASS: gdb.base/constvars.exp: print legacy +PASS: gdb.base/constvars.exp: ptype legacy +PASS: gdb.base/constvars.exp: print laconic +PASS: gdb.base/constvars.exp: ptype laconic +PASS: gdb.base/constvars.exp: print laggard +PASS: gdb.base/constvars.exp: ptype laggard +PASS: gdb.base/constvars.exp: print lagoon +PASS: gdb.base/constvars.exp: ptype lagoon +PASS: gdb.base/constvars.exp: print laity +PASS: gdb.base/constvars.exp: ptype laity +PASS: gdb.base/constvars.exp: print lambent +PASS: gdb.base/constvars.exp: ptype lambent +PASS: gdb.base/constvars.exp: print laminated +PASS: gdb.base/constvars.exp: ptype laminated +PASS: gdb.base/constvars.exp: print lampoon +PASS: gdb.base/constvars.exp: ptype lampoon +PASS: gdb.base/constvars.exp: print languid +PASS: gdb.base/constvars.exp: ptype languid +PASS: gdb.base/constvars.exp: print *legend +PASS: gdb.base/constvars.exp: ptype legend +PASS: gdb.base/constvars.exp: print *legerdemain +PASS: gdb.base/constvars.exp: ptype legerdemain +PASS: gdb.base/constvars.exp: print *leniency +PASS: gdb.base/constvars.exp: ptype leniency +PASS: gdb.base/constvars.exp: print *leonine +PASS: gdb.base/constvars.exp: ptype leonine +PASS: gdb.base/constvars.exp: print *lesion +PASS: gdb.base/constvars.exp: ptype lesion +PASS: gdb.base/constvars.exp: print *lethal +PASS: gdb.base/constvars.exp: ptype lethal +PASS: gdb.base/constvars.exp: print *lethargic +PASS: gdb.base/constvars.exp: ptype lethargic +PASS: gdb.base/constvars.exp: print *levity +PASS: gdb.base/constvars.exp: ptype levity +PASS: gdb.base/constvars.exp: print *lewd +PASS: gdb.base/constvars.exp: ptype lewd +PASS: gdb.base/constvars.exp: print *lexicographer +PASS: gdb.base/constvars.exp: ptype lexicographer +PASS: gdb.base/constvars.exp: print *lexicon +PASS: gdb.base/constvars.exp: ptype lexicon +PASS: gdb.base/constvars.exp: print *liaison +PASS: gdb.base/constvars.exp: ptype liaison +PASS: gdb.base/constvars.exp: print *libation +PASS: gdb.base/constvars.exp: ptype libation +PASS: gdb.base/constvars.exp: print *libelous +PASS: gdb.base/constvars.exp: ptype libelous +PASS: gdb.base/constvars.exp: print *libertine +PASS: gdb.base/constvars.exp: ptype libertine +PASS: gdb.base/constvars.exp: print *libidinous +PASS: gdb.base/constvars.exp: ptype libidinous +PASS: gdb.base/constvars.exp: print *languish +PASS: gdb.base/constvars.exp: ptype languish +PASS: gdb.base/constvars.exp: print *languor +PASS: gdb.base/constvars.exp: ptype languor +PASS: gdb.base/constvars.exp: print *lank +PASS: gdb.base/constvars.exp: ptype lank +PASS: gdb.base/constvars.exp: print *lapidary +PASS: gdb.base/constvars.exp: ptype lapidary +PASS: gdb.base/constvars.exp: print *larceny +PASS: gdb.base/constvars.exp: ptype larceny +PASS: gdb.base/constvars.exp: print *largess +PASS: gdb.base/constvars.exp: ptype largess +PASS: gdb.base/constvars.exp: print *lascivious +PASS: gdb.base/constvars.exp: ptype lascivious +PASS: gdb.base/constvars.exp: print *lassitude +PASS: gdb.base/constvars.exp: ptype lassitude +PASS: gdb.base/constvars.exp: print *lamprey +PASS: gdb.base/constvars.exp: ptype lamprey +PASS: gdb.base/constvars.exp: print *lariat +PASS: gdb.base/constvars.exp: ptype lariat +PASS: gdb.base/constvars.exp: print *laudanum +PASS: gdb.base/constvars.exp: ptype laudanum +PASS: gdb.base/constvars.exp: print *lecithin +PASS: gdb.base/constvars.exp: ptype lecithin +PASS: gdb.base/constvars.exp: print *leviathan +PASS: gdb.base/constvars.exp: ptype leviathan +PASS: gdb.base/constvars.exp: print *libretto +PASS: gdb.base/constvars.exp: ptype libretto +PASS: gdb.base/constvars.exp: print *lissome +PASS: gdb.base/constvars.exp: ptype lissome +PASS: gdb.base/constvars.exp: print *locust +PASS: gdb.base/constvars.exp: ptype locust +PASS: gdb.base/constvars.exp: ptype logical +PASS: gdb.base/constvars.exp: ptype lugged +PASS: gdb.base/constvars.exp: ptype luck +PASS: gdb.base/constvars.exp: ptype lunar +PASS: gdb.base/constvars.exp: ptype lumen +PASS: gdb.base/constvars.exp: ptype lurk +PASS: gdb.base/constvars.exp: ptype lush +PASS: gdb.base/constvars.exp: ptype lynx +PASS: gdb.base/constvars.exp: ptype crass +PASS: gdb.base/constvars.exp: ptype crisp +Running ./gdb.base/corefile.exp ... +Running ./gdb.base/ctxobj.exp ... +FAIL: gdb.base/ctxobj.exp: break in get_version functions (got interactive prompt) +FAIL: gdb.base/ctxobj.exp: continue to get_version_1 (the program exited) +FAIL: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from partial symtab +FAIL: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from symtab +FAIL: gdb.base/ctxobj.exp: continue to get_version_2 (the program is no longer running) +FAIL: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from partial symtab +FAIL: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from symtab +Running ./gdb.base/cursal.exp ... +PASS: gdb.base/cursal.exp: set listsize 1 +PASS: gdb.base/cursal.exp: list before run +PASS: gdb.base/cursal.exp: list in main +PASS: gdb.base/cursal.exp: list in func2 +PASS: gdb.base/cursal.exp: backtrace +PASS: gdb.base/cursal.exp: list after backtrace +PASS: gdb.base/cursal.exp: set listsize 3 +PASS: gdb.base/cursal.exp: list size 3 +Running ./gdb.base/cvexpr.exp ... +PASS: gdb.base/cvexpr.exp: set print sevenbit-strings +PASS: gdb.base/cvexpr.exp: set print address off +PASS: gdb.base/cvexpr.exp: set width 0 +PASS: gdb.base/cvexpr.exp: (const char) +PASS: gdb.base/cvexpr.exp: (const signed char) +PASS: gdb.base/cvexpr.exp: (const unsigned char) +PASS: gdb.base/cvexpr.exp: (const short) +PASS: gdb.base/cvexpr.exp: (const signed short) +PASS: gdb.base/cvexpr.exp: (const unsigned short) +PASS: gdb.base/cvexpr.exp: (const int) +PASS: gdb.base/cvexpr.exp: (const signed int) +PASS: gdb.base/cvexpr.exp: (const unsigned int) +PASS: gdb.base/cvexpr.exp: (const long) +PASS: gdb.base/cvexpr.exp: (const signed long) +PASS: gdb.base/cvexpr.exp: (const unsigned long) +PASS: gdb.base/cvexpr.exp: (const long long) +PASS: gdb.base/cvexpr.exp: (const signed long long) +PASS: gdb.base/cvexpr.exp: (const unsigned long long) +PASS: gdb.base/cvexpr.exp: (const float) +PASS: gdb.base/cvexpr.exp: (const double) +PASS: gdb.base/cvexpr.exp: (volatile char) +PASS: gdb.base/cvexpr.exp: (volatile signed char) +PASS: gdb.base/cvexpr.exp: (volatile unsigned char) +PASS: gdb.base/cvexpr.exp: (volatile short) +PASS: gdb.base/cvexpr.exp: (volatile signed short) +PASS: gdb.base/cvexpr.exp: (volatile unsigned short) +PASS: gdb.base/cvexpr.exp: (volatile int) +PASS: gdb.base/cvexpr.exp: (volatile signed int) +PASS: gdb.base/cvexpr.exp: (volatile unsigned int) +PASS: gdb.base/cvexpr.exp: (volatile long) +PASS: gdb.base/cvexpr.exp: (volatile signed long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long) +PASS: gdb.base/cvexpr.exp: (volatile long long) +PASS: gdb.base/cvexpr.exp: (volatile signed long long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long long) +PASS: gdb.base/cvexpr.exp: (volatile float) +PASS: gdb.base/cvexpr.exp: (volatile double) +PASS: gdb.base/cvexpr.exp: (const volatile int) +PASS: gdb.base/cvexpr.exp: (volatile const int) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const) +PASS: gdb.base/cvexpr.exp: (int const volatile) +PASS: gdb.base/cvexpr.exp: (int volatile const) +PASS: gdb.base/cvexpr.exp: (const volatile int *) +PASS: gdb.base/cvexpr.exp: (volatile const int *) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const *) +PASS: gdb.base/cvexpr.exp: (int const volatile *) +PASS: gdb.base/cvexpr.exp: (int volatile const *) +PASS: gdb.base/cvexpr.exp: (int * const volatile) +PASS: gdb.base/cvexpr.exp: (int * volatile const) +PASS: gdb.base/cvexpr.exp: (char const) +PASS: gdb.base/cvexpr.exp: (signed char const) +PASS: gdb.base/cvexpr.exp: (unsigned char const) +PASS: gdb.base/cvexpr.exp: (short const) +PASS: gdb.base/cvexpr.exp: (signed short const) +PASS: gdb.base/cvexpr.exp: (unsigned short const) +PASS: gdb.base/cvexpr.exp: (int const) +PASS: gdb.base/cvexpr.exp: (signed int const) +PASS: gdb.base/cvexpr.exp: (unsigned int const) +PASS: gdb.base/cvexpr.exp: (long const) +PASS: gdb.base/cvexpr.exp: (signed long const) +PASS: gdb.base/cvexpr.exp: (unsigned long const) +PASS: gdb.base/cvexpr.exp: (long long const) +PASS: gdb.base/cvexpr.exp: (signed long long const) +PASS: gdb.base/cvexpr.exp: (unsigned long long const) +PASS: gdb.base/cvexpr.exp: (float const) +PASS: gdb.base/cvexpr.exp: (double const) +PASS: gdb.base/cvexpr.exp: (char volatile) +PASS: gdb.base/cvexpr.exp: (signed char volatile) +PASS: gdb.base/cvexpr.exp: (unsigned char volatile) +PASS: gdb.base/cvexpr.exp: (short volatile) +PASS: gdb.base/cvexpr.exp: (signed short volatile) +PASS: gdb.base/cvexpr.exp: (unsigned short volatile) +PASS: gdb.base/cvexpr.exp: (int volatile) +PASS: gdb.base/cvexpr.exp: (signed int volatile) +PASS: gdb.base/cvexpr.exp: (unsigned int volatile) +PASS: gdb.base/cvexpr.exp: (long volatile) +PASS: gdb.base/cvexpr.exp: (signed long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long volatile) +PASS: gdb.base/cvexpr.exp: (long long volatile) +PASS: gdb.base/cvexpr.exp: (signed long long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long long volatile) +PASS: gdb.base/cvexpr.exp: (float volatile) +PASS: gdb.base/cvexpr.exp: (double volatile) +PASS: gdb.base/cvexpr.exp: (const enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered const) +PASS: gdb.base/cvexpr.exp: (volatile enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered volatile) +PASS: gdb.base/cvexpr.exp: (const int *) +PASS: gdb.base/cvexpr.exp: (int const *) +PASS: gdb.base/cvexpr.exp: (int * const) +PASS: gdb.base/cvexpr.exp: (const int * const) +PASS: gdb.base/cvexpr.exp: (int const * const) +PASS: gdb.base/cvexpr.exp: (const int **) +PASS: gdb.base/cvexpr.exp: (int const **) +PASS: gdb.base/cvexpr.exp: (int ** const) +PASS: gdb.base/cvexpr.exp: (const int * const *) +PASS: gdb.base/cvexpr.exp: (int const * const *) +PASS: gdb.base/cvexpr.exp: (const int * const * const) +PASS: gdb.base/cvexpr.exp: (int const * const * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct) +PASS: gdb.base/cvexpr.exp: (const union t_union) +PASS: gdb.base/cvexpr.exp: (struct t_struct const) +PASS: gdb.base/cvexpr.exp: (union t_union const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct *) +PASS: gdb.base/cvexpr.exp: (const union t_union *) +PASS: gdb.base/cvexpr.exp: (struct t_struct const *) +PASS: gdb.base/cvexpr.exp: (union t_union const *) +PASS: gdb.base/cvexpr.exp: (struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (union t_union * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (const union t_union * const) +PASS: gdb.base/cvexpr.exp: (struct t_struct const * const) +PASS: gdb.base/cvexpr.exp: (union t_union const * const) +Running ./gdb.base/dbx.exp ... +PASS: gdb.base/dbx.exp: stop in main +PASS: gdb.base/dbx.exp: status +PASS: gdb.base/dbx.exp: stop at average.c:43 +PASS: gdb.base/dbx.exp: stop in average.c:43 +PASS: gdb.base/dbx.exp: stop at main +PASS: gdb.base/dbx.exp: running to main +PASS: gdb.base/dbx.exp: assign first +PASS: gdb.base/dbx.exp: print first +PASS: gdb.base/dbx.exp: whereis my_list +PASS: gdb.base/dbx.exp: file average.c:1 +PASS: gdb.base/dbx.exp: cont 1 +PASS: gdb.base/dbx.exp: step +XFAIL: gdb.base/dbx.exp: func sum +PASS: gdb.base/dbx.exp: stop in sum +PASS: gdb.base/dbx.exp: cont 2 +XFAIL: gdb.base/dbx.exp: func print_average +Running ./gdb.base/debug-expr.exp ... +PASS: gdb.base/debug-expr.exp: set variable array[0] = 0 +PASS: gdb.base/debug-expr.exp: set variable array[1] = 1 +PASS: gdb.base/debug-expr.exp: set variable array[2] = 2 +PASS: gdb.base/debug-expr.exp: set variable array[3] = 3 +PASS: gdb.base/debug-expr.exp: set debug expression 1 +PASS: gdb.base/debug-expr.exp: print /x {char[4]} array +Running ./gdb.base/default.exp ... +PASS: gdb.base/default.exp: add-symbol-file +PASS: gdb.base/default.exp: append +PASS: gdb.base/default.exp: append binary +PASS: gdb.base/default.exp: append memory +PASS: gdb.base/default.exp: append value +PASS: gdb.base/default.exp: append binary memory +PASS: gdb.base/default.exp: append binary value +WARNING: Skipping backtrace and break tests because of GDB stub. +PASS: gdb.base/default.exp: continue +PASS: gdb.base/default.exp: continue "c" abbreviation +PASS: gdb.base/default.exp: call +PASS: gdb.base/default.exp: catch +PASS: gdb.base/default.exp: cd +PASS: gdb.base/default.exp: clear +PASS: gdb.base/default.exp: commands +PASS: gdb.base/default.exp: condition +PASS: gdb.base/default.exp: core-file +PASS: gdb.base/default.exp: delete "d" abbreviation +PASS: gdb.base/default.exp: delete +PASS: gdb.base/default.exp: define +PASS: gdb.base/default.exp: delete breakpoints +PASS: gdb.base/default.exp: delete display prompt +PASS: gdb.base/default.exp: detach +PASS: gdb.base/default.exp: directory prompt +PASS: gdb.base/default.exp: disable "dis" abbreviation +PASS: gdb.base/default.exp: disable "disa" abbreviation +PASS: gdb.base/default.exp: disable +PASS: gdb.base/default.exp: disable breakpoints +PASS: gdb.base/default.exp: disable display +PASS: gdb.base/default.exp: disassemble +PASS: gdb.base/default.exp: display +PASS: gdb.base/default.exp: do +PASS: gdb.base/default.exp: document +PASS: gdb.base/default.exp: down +PASS: gdb.base/default.exp: down-silently +PASS: gdb.base/default.exp: dump +PASS: gdb.base/default.exp: dump binary +PASS: gdb.base/default.exp: dump ihex +PASS: gdb.base/default.exp: dump memory +PASS: gdb.base/default.exp: dump srec +PASS: gdb.base/default.exp: dump tekhex +PASS: gdb.base/default.exp: dump value +PASS: gdb.base/default.exp: dump binary memory +PASS: gdb.base/default.exp: dump binary value +PASS: gdb.base/default.exp: dump ihex memory +PASS: gdb.base/default.exp: dump ihex value +PASS: gdb.base/default.exp: dump srec memory +PASS: gdb.base/default.exp: dump srec value +PASS: gdb.base/default.exp: dump tekhex memory +PASS: gdb.base/default.exp: dump tekhex value +PASS: gdb.base/default.exp: echo +PASS: gdb.base/default.exp: enable breakpoints delete +PASS: gdb.base/default.exp: enable breakpoints once +PASS: gdb.base/default.exp: enable breakpoints +PASS: gdb.base/default.exp: enable delete +PASS: gdb.base/default.exp: enable display +PASS: gdb.base/default.exp: enable once +PASS: gdb.base/default.exp: enable +PASS: gdb.base/default.exp: exec-file +PASS: gdb.base/default.exp: frame "f" abbreviation +PASS: gdb.base/default.exp: frame +PASS: gdb.base/default.exp: fg +PASS: gdb.base/default.exp: file +PASS: gdb.base/default.exp: finish +PASS: gdb.base/default.exp: forward-search +PASS: gdb.base/default.exp: gcore +PASS: gdb.base/default.exp: generate-core-file +PASS: gdb.base/default.exp: help "h" abbreviation +PASS: gdb.base/default.exp: help +PASS: gdb.base/default.exp: handle +PASS: gdb.base/default.exp: info "i" abbreviation +PASS: gdb.base/default.exp: info +PASS: gdb.base/default.exp: ignore +PASS: gdb.base/default.exp: info address +PASS: gdb.base/default.exp: info all-registers +PASS: gdb.base/default.exp: info args +PASS: gdb.base/default.exp: info bogus-gdb-command +PASS: gdb.base/default.exp: info breakpoints +PASS: gdb.base/default.exp: info copying +PASS: gdb.base/default.exp: info display +PASS: gdb.base/default.exp: info frame "f" abbreviation +PASS: gdb.base/default.exp: info frame +PASS: gdb.base/default.exp: info files +PASS: gdb.base/default.exp: info float +PASS: gdb.base/default.exp: info functions +PASS: gdb.base/default.exp: info locals +PASS: gdb.base/default.exp: info program +PASS: gdb.base/default.exp: info registers +PASS: gdb.base/default.exp: info stack "s" abbreviation +PASS: gdb.base/default.exp: info stack +PASS: gdb.base/default.exp: info set +PASS: gdb.base/default.exp: info symbol +PASS: gdb.base/default.exp: info source +PASS: gdb.base/default.exp: info sources +PASS: gdb.base/default.exp: info target +PASS: gdb.base/default.exp: info terminal +PASS: gdb.base/default.exp: info threads +PASS: gdb.base/default.exp: info types +PASS: gdb.base/default.exp: info variables +PASS: gdb.base/default.exp: info vector +PASS: gdb.base/default.exp: info warranty +PASS: gdb.base/default.exp: info watchpoints +PASS: gdb.base/default.exp: inspect +PASS: gdb.base/default.exp: jump +PASS: gdb.base/default.exp: kill +PASS: gdb.base/default.exp: list "l" abbreviation +PASS: gdb.base/default.exp: list +PASS: gdb.base/default.exp: load +PASS: gdb.base/default.exp: next "n" abbreviation +PASS: gdb.base/default.exp: next +PASS: gdb.base/default.exp: nexti "ni" abbreviation +PASS: gdb.base/default.exp: nexti +PASS: gdb.base/default.exp: output +PASS: gdb.base/default.exp: overlay +PASS: gdb.base/default.exp: overlay on +PASS: gdb.base/default.exp: overlay manual #1 +PASS: gdb.base/default.exp: overlay auto +PASS: gdb.base/default.exp: overlay off +PASS: gdb.base/default.exp: overlay list +PASS: gdb.base/default.exp: overlay map #1 +PASS: gdb.base/default.exp: overlay unmap #1 +PASS: gdb.base/default.exp: overlay manual #2 +PASS: gdb.base/default.exp: overlay map #2 +PASS: gdb.base/default.exp: overlay unmap #2 +PASS: gdb.base/default.exp: print "p" abbreviation +PASS: gdb.base/default.exp: print +PASS: gdb.base/default.exp: printf +PASS: gdb.base/default.exp: ptype +PASS: gdb.base/default.exp: pwd +PASS: gdb.base/default.exp: rbreak +PASS: gdb.base/default.exp: restore +PASS: gdb.base/default.exp: return +PASS: gdb.base/default.exp: reverse-search +PASS: gdb.base/default.exp: step "s" abbreviation #1 +PASS: gdb.base/default.exp: step #1 +PASS: gdb.base/default.exp: search +PASS: gdb.base/default.exp: section +PASS: gdb.base/default.exp: set annotate +PASS: gdb.base/default.exp: set args +PASS: gdb.base/default.exp: set check "c" abbreviation +PASS: gdb.base/default.exp: set check "ch" abbreviation +PASS: gdb.base/default.exp: set check "check" abbreviation +PASS: gdb.base/default.exp: set check range +PASS: gdb.base/default.exp: set check type +PASS: gdb.base/default.exp: set complaints +PASS: gdb.base/default.exp: set confirm +PASS: gdb.base/default.exp: set environment +PASS: gdb.base/default.exp: set height +PASS: gdb.base/default.exp: set history expansion +PASS: gdb.base/default.exp: set history filename +PASS: gdb.base/default.exp: set history save +PASS: gdb.base/default.exp: set history size +PASS: gdb.base/default.exp: set history +PASS: gdb.base/default.exp: set language +PASS: gdb.base/default.exp: set listsize +PASS: gdb.base/default.exp: set print "p" abbreviation +PASS: gdb.base/default.exp: set print "pr" abbreviation +PASS: gdb.base/default.exp: set print +PASS: gdb.base/default.exp: set print address +PASS: gdb.base/default.exp: set print array +PASS: gdb.base/default.exp: set print asm-demangle +PASS: gdb.base/default.exp: set print demangle +PASS: gdb.base/default.exp: set print elements +PASS: gdb.base/default.exp: set print object +PASS: gdb.base/default.exp: set print pretty +PASS: gdb.base/default.exp: set print sevenbit-strings +PASS: gdb.base/default.exp: set print union +PASS: gdb.base/default.exp: set print vtbl +PASS: gdb.base/default.exp: set radix +PASS: gdb.base/default.exp: set variable +PASS: gdb.base/default.exp: set verbose +PASS: gdb.base/default.exp: set width +PASS: gdb.base/default.exp: set write +PASS: gdb.base/default.exp: set +PASS: gdb.base/default.exp: shell echo Hi dad! +PASS: gdb.base/default.exp: show annotate +PASS: gdb.base/default.exp: show args +PASS: gdb.base/default.exp: show check "c" abbreviation +PASS: gdb.base/default.exp: show check "ch" abbreviation +PASS: gdb.base/default.exp: show check "check" abbreviation +PASS: gdb.base/default.exp: show check range +PASS: gdb.base/default.exp: show check type +PASS: gdb.base/default.exp: show commands +PASS: gdb.base/default.exp: show complaints +PASS: gdb.base/default.exp: show confirm +PASS: gdb.base/default.exp: show convenience +PASS: gdb.base/default.exp: show directories +PASS: gdb.base/default.exp: show editing +PASS: gdb.base/default.exp: show height +PASS: gdb.base/default.exp: show history expansion +PASS: gdb.base/default.exp: show history filename +PASS: gdb.base/default.exp: show history save +PASS: gdb.base/default.exp: show history size +PASS: gdb.base/default.exp: show history +PASS: gdb.base/default.exp: show language +PASS: gdb.base/default.exp: show listsize +PASS: gdb.base/default.exp: show p +PASS: gdb.base/default.exp: show pr +PASS: gdb.base/default.exp: show print +PASS: gdb.base/default.exp: show paths +PASS: gdb.base/default.exp: show print address +PASS: gdb.base/default.exp: show print array +PASS: gdb.base/default.exp: show print asm-demangle +PASS: gdb.base/default.exp: show print demangle +PASS: gdb.base/default.exp: show print elements +PASS: gdb.base/default.exp: show print object +PASS: gdb.base/default.exp: show print pretty +PASS: gdb.base/default.exp: show print sevenbit-strings +PASS: gdb.base/default.exp: show print union +PASS: gdb.base/default.exp: show print vtbl +PASS: gdb.base/default.exp: show prompt +PASS: gdb.base/default.exp: show radix +PASS: gdb.base/default.exp: show user +PASS: gdb.base/default.exp: show values +PASS: gdb.base/default.exp: show verbose +PASS: gdb.base/default.exp: show version +PASS: gdb.base/default.exp: show width +PASS: gdb.base/default.exp: show write +PASS: gdb.base/default.exp: show +PASS: gdb.base/default.exp: stepi "si" abbreviation +PASS: gdb.base/default.exp: stepi +PASS: gdb.base/default.exp: signal +PASS: gdb.base/default.exp: source +PASS: gdb.base/default.exp: step "s" abbreviation #2 +PASS: gdb.base/default.exp: step #2 +PASS: gdb.base/default.exp: symbol-file +PASS: gdb.base/default.exp: target child +PASS: gdb.base/default.exp: target procfs +PASS: gdb.base/default.exp: target core +PASS: gdb.base/default.exp: target exec +PASS: gdb.base/default.exp: target remote +PASS: gdb.base/default.exp: target +PASS: gdb.base/default.exp: tbreak +PASS: gdb.base/default.exp: thread +PASS: gdb.base/default.exp: thread apply +PASS: gdb.base/default.exp: thread find +PASS: gdb.base/default.exp: thread name +PASS: gdb.base/default.exp: tty +PASS: gdb.base/default.exp: until "u" abbreviation +PASS: gdb.base/default.exp: until +PASS: gdb.base/default.exp: undisplay prompt +PASS: gdb.base/default.exp: unset environment prompt +PASS: gdb.base/default.exp: unset +PASS: gdb.base/default.exp: up-silently +PASS: gdb.base/default.exp: watch +PASS: gdb.base/default.exp: whatis +PASS: gdb.base/default.exp: where +PASS: gdb.base/default.exp: x +Running ./gdb.base/define.exp ... +PASS: gdb.base/define.exp: define user command: nextwhere +FAIL: gdb.base/define.exp: use user command: nextwhere +PASS: gdb.base/define.exp: define user command: nextwh +PASS: gdb.base/define.exp: redefine user command aborted: nextwhere +PASS: gdb.base/define.exp: redefine user command: nextwhere +PASS: gdb.base/define.exp: redocumenting builtin command disallowed +PASS: gdb.base/define.exp: document user command: nextwhere +PASS: gdb.base/define.exp: re-document user command: nextwhere +PASS: gdb.base/define.exp: help user command: nextwhere +PASS: gdb.base/define.exp: set up whitespace in help string +PASS: gdb.base/define.exp: preserve whitespace in help string +PASS: gdb.base/define.exp: define user command: ifnospace +PASS: gdb.base/define.exp: test ifnospace is parsed correctly +PASS: gdb.base/define.exp: define user command: whilenospace +PASS: gdb.base/define.exp: test whilenospace is parsed correctly +PASS: gdb.base/define.exp: define user command: user-bt +PASS: gdb.base/define.exp: define hook-stop command +FAIL: gdb.base/define.exp: use hook-stop command +PASS: gdb.base/define.exp: define hook undefined command aborted: bar +PASS: gdb.base/define.exp: define hook undefined command: bar +PASS: gdb.base/define.exp: define target testsuite +PASS: gdb.base/define.exp: document target testsuite +PASS: gdb.base/define.exp: help target +PASS: gdb.base/define.exp: target testsuite +PASS: gdb.base/define.exp: show user target testsuite +PASS: gdb.base/define.exp: define target hook-testsuite +PASS: gdb.base/define.exp: define target hookpost-testsuite +PASS: gdb.base/define.exp: target testsuite with hooks +PASS: gdb.base/define.exp: set gdb_prompt +PASS: gdb.base/define.exp: reset gdb_prompt +Running ./gdb.base/del.exp ... +PASS: gdb.base/del.exp: Remove all breakpoints (del) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (del) +PASS: gdb.base/del.exp: Remove last breakpoint (del) +PASS: gdb.base/del.exp: info break after removing break on main (del) +PASS: gdb.base/del.exp: Remove all breakpoints (d) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (d) +PASS: gdb.base/del.exp: Remove last breakpoint (d) +PASS: gdb.base/del.exp: info break after removing break on main (d) +Running ./gdb.base/detach.exp ... +Running ./gdb.base/dfp-exprs.exp ... +PASS: gdb.base/dfp-exprs.exp: p 1.2df +PASS: gdb.base/dfp-exprs.exp: p -1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.234567df +PASS: gdb.base/dfp-exprs.exp: p -1.234567df +PASS: gdb.base/dfp-exprs.exp: p 1234567.df +PASS: gdb.base/dfp-exprs.exp: p -1234567.df +PASS: gdb.base/dfp-exprs.exp: p 1.2E1df +PASS: gdb.base/dfp-exprs.exp: p 1.2E10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E96df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd +PASS: gdb.base/dfp-exprs.exp: p -1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E384dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl +PASS: gdb.base/dfp-exprs.exp: p -1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E6144dl +PASS: gdb.base/dfp-exprs.exp: p 1.4df + 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df - 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df * 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df / 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4dd + 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd - 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd * 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd / 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dl + 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl - 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl * 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl / 1.2dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.df +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.dl + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 2.1df + 2.7dd +PASS: gdb.base/dfp-exprs.exp: p 2.1dd + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.6df + 2.7dl +PASS: gdb.base/dfp-exprs.exp: p 2.6dl + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.3dd + 2.2dl +PASS: gdb.base/dfp-exprs.exp: p 2.3dl + 2.2dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: p 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: p 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: ptype 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: ptype 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: ptype 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 2ll +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1.2f +PASS: gdb.base/dfp-exprs.exp: p !0.df +PASS: gdb.base/dfp-exprs.exp: p !0.dd +PASS: gdb.base/dfp-exprs.exp: p !0.dl +PASS: gdb.base/dfp-exprs.exp: p !0.5df +PASS: gdb.base/dfp-exprs.exp: p !0.5dd +PASS: gdb.base/dfp-exprs.exp: p !0.5dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p +1.2df +PASS: gdb.base/dfp-exprs.exp: p +1.2dd +PASS: gdb.base/dfp-exprs.exp: p +1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df > 1 +PASS: gdb.base/dfp-exprs.exp: p 1.2dl > 2 +PASS: gdb.base/dfp-exprs.exp: p 2 > 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 2 > 3.1dl +PASS: gdb.base/dfp-exprs.exp: p (float) -0.1df +PASS: gdb.base/dfp-exprs.exp: p (int) 8.3dd +PASS: gdb.base/dfp-exprs.exp: p (_Decimal64) 3.1 +PASS: gdb.base/dfp-exprs.exp: p (_Decimal128) 3.7df +PASS: gdb.base/dfp-exprs.exp: p (_Decimal32) 4 +Running ./gdb.base/dfp-test.exp ... +Running ./gdb.base/disabled-location.exp ... +PASS: gdb.base/disabled-location.exp: setting breakpoint on function +PASS: gdb.base/disabled-location.exp: disable location +PASS: gdb.base/disabled-location.exp: step doesn't trip on disabled location +Running ./gdb.base/disasm-end-cu.exp ... +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&main" +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&dummy_3" +PASS: gdb.base/disasm-end-cu.exp: disassemble command returned some output +Running ./gdb.base/display.exp ... +PASS: gdb.base/display.exp: break do_loops +PASS: gdb.base/display.exp: get to do_loops +PASS: gdb.base/display.exp: set watch +PASS: gdb.base/display.exp: break loop end +PASS: gdb.base/display.exp: inf disp +PASS: gdb.base/display.exp: display i +PASS: gdb.base/display.exp: display j +PASS: gdb.base/display.exp: display &k +PASS: gdb.base/display.exp: display/f f +PASS: gdb.base/display.exp: display/s &sum +PASS: gdb.base/display.exp: first disp +PASS: gdb.base/display.exp: second disp +PASS: gdb.base/display.exp: catch err +PASS: gdb.base/display.exp: disab disp 1 +PASS: gdb.base/display.exp: disab disp 2 +PASS: gdb.base/display.exp: re-enab +PASS: gdb.base/display.exp: re-enab of enab +PASS: gdb.base/display.exp: undisp +PASS: gdb.base/display.exp: info disp +PASS: gdb.base/display.exp: next hit +PASS: gdb.base/display.exp: undisp all +PASS: gdb.base/display.exp: disp *p_i +PASS: gdb.base/display.exp: p p_i = 0x0 +PASS: gdb.base/display.exp: display bad address +PASS: gdb.base/display.exp: p p_i = &i +PASS: gdb.base/display.exp: display good address +PASS: gdb.base/display.exp: undisp all again +PASS: gdb.base/display.exp: disab 3 +PASS: gdb.base/display.exp: watch off +PASS: gdb.base/display.exp: finish +PASS: gdb.base/display.exp: step +PASS: gdb.base/display.exp: tbreak in do_vars +PASS: gdb.base/display.exp: cont +PASS: gdb.base/display.exp: printf +PASS: gdb.base/display.exp: printf %d +PASS: gdb.base/display.exp: printf "%d +PASS: gdb.base/display.exp: printf "%d%d",i +PASS: gdb.base/display.exp: printf "\\!\a\f\r\t\v\b\n" +PASS: gdb.base/display.exp: re-set term +PASS: gdb.base/display.exp: printf "\w" +PASS: gdb.base/display.exp: printf "%d" j +PASS: gdb.base/display.exp: printf "%p\n", 0 +PASS: gdb.base/display.exp: printf "%p\n", 1 +PASS: gdb.base/display.exp: print/z j +PASS: gdb.base/display.exp: debug test output 1 +PASS: gdb.base/display.exp: debug test output 1a +PASS: gdb.base/display.exp: debug test output 2 +PASS: gdb.base/display.exp: debug test output 2a +PASS: gdb.base/display.exp: debug test output 3 +PASS: gdb.base/display.exp: x/0 j +PASS: gdb.base/display.exp: print/0 j +PASS: gdb.base/display.exp: ignored s +PASS: gdb.base/display.exp: no i +PASS: gdb.base/display.exp: print/a &sum +PASS: gdb.base/display.exp: print/a main+4 +PASS: gdb.base/display.exp: print/a $pc +PASS: gdb.base/display.exp: print/a &&j +Running ./gdb.base/disp-step-syscall.exp ... +Running ./gdb.base/dmsym.exp ... +PASS: gdb.base/dmsym.exp: set lang ada +PASS: gdb.base/dmsym.exp: break pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: info line pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: set lang auto +PASS: gdb.base/dmsym.exp: Run until breakpoint at BREAK +PASS: gdb.base/dmsym.exp: continue +PASS: gdb.base/dmsym.exp: print val +Running ./gdb.base/dprintf.exp ... +PASS: gdb.base/dprintf.exp: dprintf +PASS: gdb.base/dprintf.exp: dprintf foo +PASS: gdb.base/dprintf.exp: dprintf 29 +PASS: gdb.base/dprintf.exp: dprintf foo,"At foo entry\n" +PASS: gdb.base/dprintf.exp: ignore $bpnum 1 +PASS: gdb.base/dprintf.exp: dprintf 26,"arg=%d, g=%d\n", arg, g +PASS: gdb.base/dprintf.exp: dprintf info 1 +PASS: gdb.base/dprintf.exp: break 27 +PASS: gdb.base/dprintf.exp: 1st dprintf, gdb +PASS: gdb.base/dprintf.exp: 2nd dprintf, gdb +PASS: gdb.base/dprintf.exp: Set dprintf style to agent - can do +FAIL: gdb.base/dprintf.exp: 1st dprintf, agent +FAIL: gdb.base/dprintf.exp: 2nd dprintf, agent +FAIL: gdb.base/dprintf.exp: dprintf info 2 (pattern 6) +PASS: gdb.base/dprintf.exp: Set dprintf style to an unrecognized type +Running ./gdb.base/dprintf-next.exp ... +PASS: gdb.base/dprintf-next.exp: dprintf 24, "%d\n", x +PASS: gdb.base/dprintf-next.exp: next 1 +PASS: gdb.base/dprintf-next.exp: next 2 +Running ./gdb.base/dprintf-non-stop.exp ... +UNSUPPORTED: gdb.base/dprintf-non-stop.exp: Testing dprintf with remote/non-stop is not supported. +Running ./gdb.base/dprintf-pending.exp ... +PASS: gdb.base/dprintf-pending.exp: without format: set pending dprintf +FAIL: gdb.base/dprintf-pending.exp: without format: resolved dprintf fails to be re-set +PASS: gdb.base/dprintf-pending.exp: without symbols: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: without symbols: single pending dprintf info +FAIL: gdb.base/dprintf-pending.exp: without symbols: run to resolved dprintf (the program exited) +PASS: gdb.base/dprintf-pending.exp: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: single pending dprintf info +FAIL: gdb.base/dprintf-pending.exp: run to resolved dprintf (the program exited) +Running ./gdb.base/dump.exp ... +PASS: gdb.base/dump.exp: inaccessible memory is reported +PASS: gdb.base/dump.exp: endianness: little +PASS: gdb.base/dump.exp: dump array as value, default +PASS: gdb.base/dump.exp: dump struct as value, default +PASS: gdb.base/dump.exp: dump array as value, binary +PASS: gdb.base/dump.exp: dump struct as value, binary +PASS: gdb.base/dump.exp: dump array as value, srec +PASS: gdb.base/dump.exp: dump struct as value, srec +PASS: gdb.base/dump.exp: dump array as value, intel hex +PASS: gdb.base/dump.exp: dump struct as value, intel hex +PASS: gdb.base/dump.exp: dump array as value, tekhex +PASS: gdb.base/dump.exp: dump struct as value, tekhex +PASS: gdb.base/dump.exp: capture /x &intarray[0] +PASS: gdb.base/dump.exp: capture /x &intarray[32] +PASS: gdb.base/dump.exp: capture /x &intstruct +PASS: gdb.base/dump.exp: capture /x &intstruct + 1 +PASS: gdb.base/dump.exp: capture intarray +PASS: gdb.base/dump.exp: capture intstruct +PASS: gdb.base/dump.exp: capture type of pointer &intarray +PASS: gdb.base/dump.exp: capture type of pointer &intstruct +PASS: gdb.base/dump.exp: dump array as memory, default +PASS: gdb.base/dump.exp: dump struct as memory, default +PASS: gdb.base/dump.exp: dump array as memory, binary +PASS: gdb.base/dump.exp: dump struct as memory, binary +PASS: gdb.base/dump.exp: dump array as memory, srec +PASS: gdb.base/dump.exp: dump struct as memory, srec +PASS: gdb.base/dump.exp: dump array as memory, ihex +PASS: gdb.base/dump.exp: dump struct as memory, ihex +PASS: gdb.base/dump.exp: dump array as memory, tekhex +PASS: gdb.base/dump.exp: dump struct as memory, tekhex +PASS: gdb.base/dump.exp: dump array as mem, srec, expressions +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, srec; file restored ok +PASS: gdb.base/dump.exp: array as value, srec; capture intarray +PASS: gdb.base/dump.exp: array as value, srec; value restored ok +PASS: gdb.base/dump.exp: struct as value, srec; file restored ok +PASS: gdb.base/dump.exp: struct as value, srec; capture intstruct +PASS: gdb.base/dump.exp: struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: zero all +PASS: gdb.base/dump.exp: array as memory, srec; file restored ok +PASS: gdb.base/dump.exp: array as memory, srec; capture intarray +PASS: gdb.base/dump.exp: array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; file restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, ihex; file restored ok +PASS: gdb.base/dump.exp: array as value, ihex; capture intarray +PASS: gdb.base/dump.exp: array as value, ihex; value restored ok +PASS: gdb.base/dump.exp: struct as value, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as value, ihex; capture intstruct +PASS: gdb.base/dump.exp: struct as value, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: array as memory, ihex; capture intarray +PASS: gdb.base/dump.exp: array as memory, ihex; value restored ok +PASS: gdb.base/dump.exp: struct as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, ihex; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as value, tekhex; capture intarray +PASS: gdb.base/dump.exp: array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; capture intstruct +PASS: gdb.base/dump.exp: struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as memory, tekhex; capture intarray +PASS: gdb.base/dump.exp: array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, binary; file restored ok +PASS: gdb.base/dump.exp: array as value, binary; capture intarray +PASS: gdb.base/dump.exp: array as value, binary; value restored ok +PASS: gdb.base/dump.exp: struct as value, binary; file restored ok +PASS: gdb.base/dump.exp: struct as value, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as value, binary; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, binary; file restored ok +PASS: gdb.base/dump.exp: array as memory, binary; capture intarray +PASS: gdb.base/dump.exp: array as memory, binary; value restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; file restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray2[0] +PASS: gdb.base/dump.exp: capture /x &intstruct2 +PASS: gdb.base/dump.exp: capture (char *) &intarray2 - (char *) &intarray +PASS: gdb.base/dump.exp: capture (char *) &intstruct2 - (char *) &intstruct +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, srec; file restored ok +PASS: gdb.base/dump.exp: array copy, srec; capture intarray2 +PASS: gdb.base/dump.exp: array copy, srec; value restored ok +PASS: gdb.base/dump.exp: struct copy, srec; file restored ok +PASS: gdb.base/dump.exp: struct copy, srec; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, ihex; file restored ok +PASS: gdb.base/dump.exp: array copy, ihex; capture intarray2 +PASS: gdb.base/dump.exp: array copy, ihex; value restored ok +PASS: gdb.base/dump.exp: struct copy, ihex; file restored ok +PASS: gdb.base/dump.exp: struct copy, ihex; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: array copy, tekhex; capture intarray2 +PASS: gdb.base/dump.exp: array copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, binary; file restored ok +PASS: gdb.base/dump.exp: array copy, binary; capture intarray2 +PASS: gdb.base/dump.exp: array copy, binary; value restored ok +PASS: gdb.base/dump.exp: struct copy, binary; file restored ok +PASS: gdb.base/dump.exp: struct copy, binary; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray[3] +PASS: gdb.base/dump.exp: capture /x &intarray[4] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[3] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[4] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, srec; file restored ok +PASS: gdb.base/dump.exp: array partial, srec; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, srec; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 1 +PASS: gdb.base/dump.exp: element 4 not changed - 1 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, ihex; file restored ok +PASS: gdb.base/dump.exp: array partial, ihex; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, ihex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 2 +PASS: gdb.base/dump.exp: element 4 not changed - 2 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, tekhex; file restored ok +PASS: gdb.base/dump.exp: array partial, tekhex; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, tekhex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 3 +PASS: gdb.base/dump.exp: element 4 not changed - 3 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, binary; file restored ok +PASS: gdb.base/dump.exp: array partial, binary; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, binary; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 4 +PASS: gdb.base/dump.exp: element 4 not changed - 4 +PASS: gdb.base/dump.exp: array partial with expressions; file restored ok +PASS: gdb.base/dump.exp: array partial with expressions; capture intarray2[3] +PASS: gdb.base/dump.exp: array partial with expressions; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed, == 4 +PASS: gdb.base/dump.exp: element 4 not changed, == 4 +PASS: gdb.base/dump.exp: setting little endianness +PASS: gdb.base/dump.exp: file binfile; capture intarray +PASS: gdb.base/dump.exp: start with intarray un-initialized +PASS: gdb.base/dump.exp: file binfile; capture intstruct +PASS: gdb.base/dump.exp: start with intstruct un-initialized +PASS: gdb.base/dump.exp: reload array as value, srec; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, srec; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, srec; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, srec; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as memory, srec; value restored ok +PASS: gdb.base/dump.exp: reload array as value, intel hex; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as value, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, intel hex; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as value, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, intel hex; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as memory, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, intel hex; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as memory, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload array as value, tekhex; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, tekhex; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, tekhex; capture * (int (*)[32]) 0x54ab30c4 +PASS: gdb.base/dump.exp: reload array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, tekhex; capture * (struct teststruct *) 0x54ab300c +PASS: gdb.base/dump.exp: reload struct as memory, tekhex; value restored ok +Running ./gdb.base/duplicate-bp.exp ... +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete #2, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable #1, delete #2, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable #2, delete #1, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable #1, delete #3, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable #3, delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable #2, delete #3, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable #3, delete #2, stop at #1 +Running ./gdb.base/dup-sect.exp ... +PASS: gdb.base/dup-sect.exp: rename section +PASS: gdb.base/dup-sect.exp: split +PASS: gdb.base/dup-sect.exp: strip +PASS: gdb.base/dup-sect.exp: var1 after strip +PASS: gdb.base/dup-sect.exp: var2 after strip +Running ./gdb.base/echo.exp ... +PASS: gdb.base/echo.exp: Echo test +Running ./gdb.base/empty_exe.exp ... +PASS: gdb.base/empty_exe.exp: file '' +PASS: gdb.base/empty_exe.exp: print 1 +Running ./gdb.base/ena-dis-br.exp ... +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: enable break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +PASS: gdb.base/ena-dis-br.exp: continue to break marker1 +PASS: gdb.base/ena-dis-br.exp: delete break marker1 +PASS: gdb.base/ena-dis-br.exp: break marker2 +PASS: gdb.base/ena-dis-br.exp: enable once break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +FAIL: gdb.base/ena-dis-br.exp: setting breakpoint at exit +PASS: gdb.base/ena-dis-br.exp: rerun to main +FAIL: gdb.base/ena-dis-br.exp: setting breakpoint at exit +PASS: gdb.base/ena-dis-br.exp: break marker3 +PASS: gdb.base/ena-dis-br.exp: enable del break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: break marker4 +PASS: gdb.base/ena-dis-br.exp: disable break marker4 +PASS: gdb.base/ena-dis-br.exp: info break marker4 +PASS: gdb.base/ena-dis-br.exp: break 113 +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break with count +PASS: gdb.base/ena-dis-br.exp: continue from enable count, first time +PASS: gdb.base/ena-dis-br.exp: continue from enable count, second time +PASS: gdb.base/ena-dis-br.exp: continue through enable count, now disabled +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore non-existent break +PASS: gdb.base/ena-dis-br.exp: ignore break with missing ignore count +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 -1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 0 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: info ignored break marker1 +FAIL: gdb.base/ena-dis-br.exp: setting breakpoint at exit +PASS: gdb.base/ena-dis-br.exp: rerun to main +FAIL: gdb.base/ena-dis-br.exp: continue to break marker1, 2nd time (the program exited) +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: enable del break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +FAIL: gdb.base/ena-dis-br.exp: setting breakpoint at exit +PASS: gdb.base/ena-dis-br.exp: rerun to main +FAIL: gdb.base/ena-dis-br.exp: continue to ignored & auto-deleted break marker1 (the program exited) +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break marker1 +FAIL: gdb.base/ena-dis-br.exp: setting breakpoint at exit +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: info ignored & disabled break marker1 +PASS: gdb.base/ena-dis-br.exp: prepare to continue with ignore count +PASS: gdb.base/ena-dis-br.exp: continue with ignore count +PASS: gdb.base/ena-dis-br.exp: step +PASS: gdb.base/ena-dis-br.exp: continue with ignore count, not stopped at bpt +Running ./gdb.base/ending-run.exp ... +PASS: gdb.base/ending-run.exp: bpt at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:14, one +PASS: gdb.base/ending-run.exp: b ending-run.c:31 +PASS: gdb.base/ending-run.exp: run +PASS: gdb.base/ending-run.exp: clear worked +PASS: gdb.base/ending-run.exp: cleared bp at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:1 +PASS: gdb.base/ending-run.exp: b ending-run.c:14, two +PASS: gdb.base/ending-run.exp: Cleared 2 by line +PASS: gdb.base/ending-run.exp: b ending-run.c:14 +PASS: gdb.base/ending-run.exp: Breakpoint 7 at *ending-run.c:14 +PASS: gdb.base/ending-run.exp: Clear 2 by default +PASS: gdb.base/ending-run.exp: all set to continue +PASS: gdb.base/ending-run.exp: cont +FAIL: gdb.base/ending-run.exp: step out of main +Running ./gdb.base/enum_cond.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/armv7a-cros-linux-gnueabi/binutils-bin/2.22/ld.bfd.real: warning: /tmp/ccoeaZYK.o uses variable-size enums yet the output is to use 32-bit enums; use of enum values across objects may fail +UNTESTED: gdb.base/enum_cond.exp: Could not compile enum_cond.c +Running ./gdb.base/enumval.exp ... +PASS: gdb.base/enumval.exp: print e +PASS: gdb.base/enumval.exp: print f +PASS: gdb.base/enumval.exp: print J +PASS: gdb.base/enumval.exp: print K +Running ./gdb.base/environ.exp ... +Running ./gdb.base/eu-strip-infcall.exp ... +PASS: gdb.base/eu-strip-infcall.exp: infcall +Running ./gdb.base/eval.exp ... +PASS: gdb.base/eval.exp: Initialize $a. +PASS: gdb.base/eval.exp: First eval. +PASS: gdb.base/eval.exp: Second eval. +Running ./gdb.base/eval-skip.exp ... +PASS: gdb.base/eval-skip.exp: set variable x=14 +PASS: gdb.base/eval-skip.exp: set variable y=2 +PASS: gdb.base/eval-skip.exp: set variable z=2 +PASS: gdb.base/eval-skip.exp: set variable w=3 +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x-y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x*y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x/y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x%y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x||y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x|y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x^y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x < y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x <= y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x==y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x!=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x<<31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>>31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (!x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (~x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (-x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x++)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (++x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x--)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (--x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+=7)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x=y)) +Running ./gdb.base/exe-lock.exp ... +FAIL: gdb.base/exe-lock.exp: setting breakpoint at exit +Running ./gdb.base/expand-psymtabs.exp ... +PASS: gdb.base/expand-psymtabs.exp: Expand psymtabs +Running ./gdb.base/exprs.exp ... +PASS: gdb.base/exprs.exp: print char == (setup) +PASS: gdb.base/exprs.exp: print char == (print v_char == 0) +PASS: gdb.base/exprs.exp: print char == (print v_char == 127) +PASS: gdb.base/exprs.exp: print char != (setup) +PASS: gdb.base/exprs.exp: print char != (print v_char != 0) +PASS: gdb.base/exprs.exp: print char != (print v_char != 127) +PASS: gdb.base/exprs.exp: print char < (setup) +PASS: gdb.base/exprs.exp: print char < (print v_char < 0) +PASS: gdb.base/exprs.exp: print char < (print v_char < 127) +PASS: gdb.base/exprs.exp: print char > (setup) +PASS: gdb.base/exprs.exp: print char > (print v_char > 0) +PASS: gdb.base/exprs.exp: print char > (print v_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (setup) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 127) +PASS: gdb.base/exprs.exp: print signed char != (setup) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 127) +PASS: gdb.base/exprs.exp: print signed char < (setup) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (setup) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == -1) +PASS: gdb.base/exprs.exp: print signed char != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != -1) +PASS: gdb.base/exprs.exp: print signed char < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 127) +PASS: gdb.base/exprs.exp: print unsigned char != (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 127) +PASS: gdb.base/exprs.exp: print unsigned char < (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == ~0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != ~0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print signed short == (setup) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short != (setup) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short < (setup) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (setup) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == -1) +PASS: gdb.base/exprs.exp: print signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != -1) +PASS: gdb.base/exprs.exp: print signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short != (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short < (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == -1) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != -1) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short != (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short < (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print sizeof (v_unsigned_short) < sizeof (~0) && v_unsigned_short == ~0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (setup) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int != (setup) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int < (setup) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (setup) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == -1) +PASS: gdb.base/exprs.exp: print signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != -1) +PASS: gdb.base/exprs.exp: print signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int != (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int < (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == -1) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != -1) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int != (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int < (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == ~0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (setup) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long != (setup) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long < (setup) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (setup) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == -1) +PASS: gdb.base/exprs.exp: print signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != -1) +PASS: gdb.base/exprs.exp: print signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long != (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long < (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == -1) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != -1) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long != (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long < (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == ~0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (print (void*)v_signed_char) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (print (void*)v_signed_short) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (print (void*)v_signed_int) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (print (void*)v_signed_long) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (print (void*)v_unsigned_char) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (print (void*)v_unsigned_short) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (print (void*)v_unsigned_int) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (print (void*)v_unsigned_long) +PASS: gdb.base/exprs.exp: sizeof (long long) > sizeof (long) (true) +PASS: gdb.base/exprs.exp: truncate (void*) 0x00000000ffffffff + 1 +PASS: gdb.base/exprs.exp: truncate (void*) 0xffffffff00000000 - 1 +PASS: gdb.base/exprs.exp: \$[0-9]* = "xy" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = "xyz" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: set output-radix 8 +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = 0 (setup) +PASS: gdb.base/exprs.exp: set output-radix 10 +PASS: gdb.base/exprs.exp: set variable v_int = 1 +PASS: gdb.base/exprs.exp: print v_int++ +PASS: gdb.base/exprs.exp: print ++v_int +PASS: gdb.base/exprs.exp: print v_int-- +PASS: gdb.base/exprs.exp: print --v_int +PASS: gdb.base/exprs.exp: print v_int++ = 5 +PASS: gdb.base/exprs.exp: print v_int-- = 5 +PASS: gdb.base/exprs.exp: print v_int_array_init +PASS: gdb.base/exprs.exp: print *v_int_array_init@1 +PASS: gdb.base/exprs.exp: print *v_int_array_init@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@1 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[1]@1 +PASS: gdb.base/exprs.exp: set variable v_short_array[0] = 42 +PASS: gdb.base/exprs.exp: print {short} v_short_array +PASS: gdb.base/exprs.exp: print (void) v_int_pointer +PASS: gdb.base/exprs.exp: print & (void) v_char +Running ./gdb.base/fileio.exp ... +Running ./gdb.base/find.exp ... +PASS: gdb.base/find.exp: breakpoint function in file +PASS: gdb.base/find.exp: run until function breakpoint +PASS: gdb.base/find.exp: find string pattern +PASS: gdb.base/find.exp: pattern not found at end of range +PASS: gdb.base/find.exp: pattern found at end of range +PASS: gdb.base/find.exp: max-count +PASS: gdb.base/find.exp: $_ +PASS: gdb.base/find.exp: $numfound +PASS: gdb.base/find.exp: size,max-count, /1b +PASS: gdb.base/find.exp: size,max-count, /b1 +PASS: gdb.base/find.exp: size,max-count, /b/1 +PASS: gdb.base/find.exp: size,max-count, /1/b +PASS: gdb.base/find.exp: find byte pattern with end address +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find mixed-sized pattern +PASS: gdb.base/find.exp: search spanning large range +PASS: gdb.base/find.exp: find int64_search_buf, +64/8*100, int64_search_buf +Running ./gdb.base/find-unmapped.exp ... +Running ./gdb.base/finish.exp ... +PASS: gdb.base/finish.exp: set break on void_func +PASS: gdb.base/finish.exp: continue to void_func +PASS: gdb.base/finish.exp: finish from void_func +PASS: gdb.base/finish.exp: set break on char_func +PASS: gdb.base/finish.exp: continue to char_func +PASS: gdb.base/finish.exp: finish from char_func +PASS: gdb.base/finish.exp: set break on short_func +PASS: gdb.base/finish.exp: continue to short_func +PASS: gdb.base/finish.exp: finish from short_func +PASS: gdb.base/finish.exp: set break on int_func +PASS: gdb.base/finish.exp: continue to int_func +PASS: gdb.base/finish.exp: finish from int_func +PASS: gdb.base/finish.exp: set break on long_func +PASS: gdb.base/finish.exp: continue to long_func +PASS: gdb.base/finish.exp: finish from long_func +PASS: gdb.base/finish.exp: set break on long_long_func +PASS: gdb.base/finish.exp: continue to long_long_func +PASS: gdb.base/finish.exp: finish from long_long_func +PASS: gdb.base/finish.exp: set break on float_func +PASS: gdb.base/finish.exp: continue to float_func +PASS: gdb.base/finish.exp: finish from float_func +PASS: gdb.base/finish.exp: set break on double_func +PASS: gdb.base/finish.exp: continue to double_func +PASS: gdb.base/finish.exp: finish from double_func +PASS: gdb.base/finish.exp: Testing the "fin" abbreviation for "finish" +Running ./gdb.base/fixsection.exp ... +PASS: gdb.base/fixsection.exp: breakpoint at static_fun +Running ./gdb.base/float.exp ... +PASS: gdb.base/float.exp: info float (VFP) +PASS: gdb.base/float.exp: step +PASS: gdb.base/float.exp: finish +Running ./gdb.base/foll-exec.exp ... +Running ./gdb.base/foll-fork.exp ... +Running ./gdb.base/foll-vfork.exp ... +Running ./gdb.base/fortran-sym-case.exp ... +PASS: gdb.base/fortran-sym-case.exp: set language fortran +PASS: gdb.base/fortran-sym-case.exp: frame +Running ./gdb.base/frame-args.exp ... +PASS: gdb.base/frame-args.exp: set print frame-arguments all +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to all +PASS: gdb.base/frame-args.exp: set print frame-arguments scalars +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to scalars +PASS: gdb.base/frame-args.exp: set print frame-arguments none +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to none +Running ./gdb.base/freebpcmd.exp ... +PASS: gdb.base/freebpcmd.exp: set breakpoint +PASS: gdb.base/freebpcmd.exp: send breakpoint commands +PASS: gdb.base/freebpcmd.exp: run program with breakpoint commands +Running ./gdb.base/fullname.exp ... +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint at main - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint at main - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built other +PASS: gdb.base/fullname.exp: set breakpoint at main - built other +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built other +Running ./gdb.base/fullpath-expand.exp ... +PASS: gdb.base/fullpath-expand.exp: rbreak XXX/fullpath-expand-func.c:func +PASS: gdb.base/fullpath-expand.exp: list func +PASS: gdb.base/fullpath-expand.exp: info source +Running ./gdb.base/funcargs.exp ... +PASS: gdb.base/funcargs.exp: set print frame-arguments all +PASS: gdb.base/funcargs.exp: run to call0a +PASS: gdb.base/funcargs.exp: print c after run to call0a +PASS: gdb.base/funcargs.exp: print s after run to call0a +PASS: gdb.base/funcargs.exp: print i after run to call0a +PASS: gdb.base/funcargs.exp: print l after run to call0a +PASS: gdb.base/funcargs.exp: continue to call0b +PASS: gdb.base/funcargs.exp: continue to call0c +PASS: gdb.base/funcargs.exp: continue to call0d +PASS: gdb.base/funcargs.exp: continue to call0e +PASS: gdb.base/funcargs.exp: run to call1a +PASS: gdb.base/funcargs.exp: print uc +PASS: gdb.base/funcargs.exp: print us +PASS: gdb.base/funcargs.exp: print ui +PASS: gdb.base/funcargs.exp: print ul +PASS: gdb.base/funcargs.exp: continue to call1b +PASS: gdb.base/funcargs.exp: continue to call1c +PASS: gdb.base/funcargs.exp: continue to call1d +PASS: gdb.base/funcargs.exp: continue to call1e +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: print c after run to call2a +PASS: gdb.base/funcargs.exp: print f1 after run to call2a +PASS: gdb.base/funcargs.exp: print s after run to call2a +PASS: gdb.base/funcargs.exp: print d1 after run to call2a +PASS: gdb.base/funcargs.exp: print i after run to call2a +PASS: gdb.base/funcargs.exp: print f2 after run to call2a +PASS: gdb.base/funcargs.exp: print l after run to call2a +PASS: gdb.base/funcargs.exp: print d2 after run to call2a +PASS: gdb.base/funcargs.exp: continue to call2b +PASS: gdb.base/funcargs.exp: continue to call2c +PASS: gdb.base/funcargs.exp: continue to call2d +PASS: gdb.base/funcargs.exp: continue to call2e +PASS: gdb.base/funcargs.exp: continue to call2f +PASS: gdb.base/funcargs.exp: continue to call2g +PASS: gdb.base/funcargs.exp: continue to call2h +PASS: gdb.base/funcargs.exp: continue to call2i +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: continue to callcb +PASS: gdb.base/funcargs.exp: continue to callcc +PASS: gdb.base/funcargs.exp: continue to callcd +PASS: gdb.base/funcargs.exp: continue to callce +PASS: gdb.base/funcargs.exp: continue to callcf +PASS: gdb.base/funcargs.exp: run to callc1a +PASS: gdb.base/funcargs.exp: continue to callc1b +PASS: gdb.base/funcargs.exp: run to callc2a +PASS: gdb.base/funcargs.exp: continue to callc2b +PASS: gdb.base/funcargs.exp: run to call3a +PASS: gdb.base/funcargs.exp: print *cp +PASS: gdb.base/funcargs.exp: print *sp +PASS: gdb.base/funcargs.exp: print *ip +PASS: gdb.base/funcargs.exp: print *lp +PASS: gdb.base/funcargs.exp: continue to call3b +PASS: gdb.base/funcargs.exp: print *ucp +PASS: gdb.base/funcargs.exp: print *usp +PASS: gdb.base/funcargs.exp: print *uip +PASS: gdb.base/funcargs.exp: print *ulp +PASS: gdb.base/funcargs.exp: continue to call3c +PASS: gdb.base/funcargs.exp: print *fp +PASS: gdb.base/funcargs.exp: print *dp +PASS: gdb.base/funcargs.exp: run to call4a +PASS: gdb.base/funcargs.exp: print *stp +PASS: gdb.base/funcargs.exp: continue to call4b +PASS: gdb.base/funcargs.exp: print *unp (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: locate actual args, structs/unions passed by reference +PASS: gdb.base/funcargs.exp: run to call5a +PASS: gdb.base/funcargs.exp: print st +PASS: gdb.base/funcargs.exp: continue to call5b (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: print un (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: run to call6a +PASS: gdb.base/funcargs.exp: backtrace from call6a +PASS: gdb.base/funcargs.exp: continue to call6b +PASS: gdb.base/funcargs.exp: backtrace from call6b +PASS: gdb.base/funcargs.exp: continue to call6c +PASS: gdb.base/funcargs.exp: backtrace from call6c +PASS: gdb.base/funcargs.exp: continue to call6d +PASS: gdb.base/funcargs.exp: backtrace from call6d +PASS: gdb.base/funcargs.exp: continue to call6e +PASS: gdb.base/funcargs.exp: backtrace from call6e +PASS: gdb.base/funcargs.exp: continue to call6f +PASS: gdb.base/funcargs.exp: backtrace from call6f +PASS: gdb.base/funcargs.exp: continue to call6g +PASS: gdb.base/funcargs.exp: backtrace from call6g +PASS: gdb.base/funcargs.exp: continue to call6h +PASS: gdb.base/funcargs.exp: backtrace from call6h +PASS: gdb.base/funcargs.exp: continue to call6i +PASS: gdb.base/funcargs.exp: backtrace from call6i +PASS: gdb.base/funcargs.exp: continue to call6j +PASS: gdb.base/funcargs.exp: backtrace from call6j +PASS: gdb.base/funcargs.exp: continue to call6k +PASS: gdb.base/funcargs.exp: backtrace from call6k +PASS: gdb.base/funcargs.exp: run to call7a +PASS: gdb.base/funcargs.exp: backtrace from call7a +PASS: gdb.base/funcargs.exp: continue to call7b +PASS: gdb.base/funcargs.exp: backtrace from call7b +PASS: gdb.base/funcargs.exp: continue to call7c +PASS: gdb.base/funcargs.exp: backtrace from call7c +PASS: gdb.base/funcargs.exp: continue to call7d +PASS: gdb.base/funcargs.exp: backtrace from call7d +PASS: gdb.base/funcargs.exp: continue to call7e +PASS: gdb.base/funcargs.exp: backtrace from call7e +PASS: gdb.base/funcargs.exp: continue to call7f +PASS: gdb.base/funcargs.exp: backtrace from call7f +PASS: gdb.base/funcargs.exp: continue to call7g +PASS: gdb.base/funcargs.exp: backtrace from call7g +PASS: gdb.base/funcargs.exp: continue to call7h +PASS: gdb.base/funcargs.exp: backtrace from call7h +PASS: gdb.base/funcargs.exp: continue to call7i +PASS: gdb.base/funcargs.exp: backtrace from call7i +PASS: gdb.base/funcargs.exp: continue to call7j +PASS: gdb.base/funcargs.exp: backtrace from call7j +PASS: gdb.base/funcargs.exp: continue to call7k +PASS: gdb.base/funcargs.exp: backtrace from call7k +PASS: gdb.base/funcargs.exp: run to hitbottom +PASS: gdb.base/funcargs.exp: recursive passing of structs by value +PASS: gdb.base/funcargs.exp: print c after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: next in localvars_after_alloca() +PASS: gdb.base/funcargs.exp: print c in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l in localvars_after_alloca +PASS: gdb.base/funcargs.exp: backtrace after alloca +PASS: gdb.base/funcargs.exp: print c in call_after_alloca +PASS: gdb.base/funcargs.exp: print s in call_after_alloca +PASS: gdb.base/funcargs.exp: print i in call_after_alloca +PASS: gdb.base/funcargs.exp: print l in call_after_alloca +PASS: gdb.base/funcargs.exp: backtrace from call_after_alloca_subr +PASS: gdb.base/funcargs.exp: continue to call0a +PASS: gdb.base/funcargs.exp: print c in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print s in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print i in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print l in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: backtrace in indirectly called function +PASS: gdb.base/funcargs.exp: finish from indirectly called function +PASS: gdb.base/funcargs.exp: stepping into indirectly called function +PASS: gdb.base/funcargs.exp: finish from marker_call_with_trampolines +PASS: gdb.base/funcargs.exp: stepping into function called with trampolines +PASS: gdb.base/funcargs.exp: backtrace through call with trampolines +PASS: gdb.base/funcargs.exp: stepping back to main from function called with trampolines +Running ./gdb.base/gcore-buffer-overflow.exp ... +PASS: gdb.base/gcore-buffer-overflow.exp: help gcore +PASS: gdb.base/gcore-buffer-overflow.exp: Set buffer exceeding arguments +PASS: gdb.base/gcore-buffer-overflow.exp: save a corefile +Running ./gdb.base/gcore.exp ... +PASS: gdb.base/gcore.exp: help gcore +PASS: gdb.base/gcore.exp: set breakpoint at terminal_func +PASS: gdb.base/gcore.exp: continue to terminal_func +PASS: gdb.base/gcore.exp: save a corefile +PASS: gdb.base/gcore.exp: re-load generated corefile +PASS: gdb.base/gcore.exp: where in corefile +PASS: gdb.base/gcore.exp: corefile restored general registers +PASS: gdb.base/gcore.exp: corefile restored all registers +PASS: gdb.base/gcore.exp: corefile restored extern array +PASS: gdb.base/gcore.exp: corefile restored static array +PASS: gdb.base/gcore.exp: corefile restored un-initialized array +PASS: gdb.base/gcore.exp: corefile restored heap array +PASS: gdb.base/gcore.exp: corefile restored stack array +PASS: gdb.base/gcore.exp: corefile restored backtrace +Running ./gdb.base/gcore-relro.exp ... +PASS: gdb.base/gcore-relro.exp: help gcore +Running ./gdb.base/gdb1056.exp ... +PASS: gdb.base/gdb1056.exp: print 1/0 +PASS: gdb.base/gdb1056.exp: Test unsigned division by zero +Running ./gdb.base/gdb1090.exp ... +PASS: gdb.base/gdb1090.exp: continue to breakpoint: break-here +PASS: gdb.base/gdb1090.exp: print s24 +Running ./gdb.base/gdb11530.exp ... +PASS: gdb.base/gdb11530.exp: print a.i +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) == sizeof (int) +Running ./gdb.base/gdb11531.exp ... +PASS: gdb.base/gdb11531.exp: Set watchpoint +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at next +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at continue +Running ./gdb.base/gdb1250.exp ... +Running ./gdb.base/gdb1555.exp ... +FAIL: gdb.base/gdb1555.exp: Step into shared lib function +FAIL: gdb.base/gdb1555.exp: Next while in a shared lib function +Running ./gdb.base/gdb1821.exp ... +PASS: gdb.base/gdb1821.exp: print /x bar +Running ./gdb.base/gdbindex-stabs.exp ... +PASS: gdb.base/gdbindex-stabs.exp: list stabs_function +Running ./gdb.base/gdbvars.exp ... +PASS: gdb.base/gdbvars.exp: set print sevenbit-strings +PASS: gdb.base/gdbvars.exp: Set value-history[1] using $1 +PASS: gdb.base/gdbvars.exp: Set value-history[2] using $2 +PASS: gdb.base/gdbvars.exp: Set value-history[3] using $3 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.base/gdbvars.exp: print 108 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.base/gdbvars.exp: Print value-history[1] using explicit index $1 +PASS: gdb.base/gdbvars.exp: Print value-history[2] using explicit index $2 +PASS: gdb.base/gdbvars.exp: Print value-history[3] using explicit index $3 +PASS: gdb.base/gdbvars.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.base/gdbvars.exp: Use value-history element in arithmetic expression +PASS: gdb.base/gdbvars.exp: Set a new convenience variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable to a new value +PASS: gdb.base/gdbvars.exp: Print new contents of convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable $_ +PASS: gdb.base/gdbvars.exp: Print contents of convenience variable $_ +PASS: gdb.base/gdbvars.exp: Use convenience variable in arithmetic expression +PASS: gdb.base/gdbvars.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.base/gdbvars.exp: Print contents of uninitialized convenience variable +PASS: gdb.base/gdbvars.exp: Set a new convenience variable to a program variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable of program variable +Running ./gdb.base/gnu-debugdata.exp ... +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke armv7a-cros-linux-gnueabi-nm +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke sort +PASS: gdb.base/gnu-debugdata.exp: nm - invoke armv7a-cros-linux-gnueabi-nm +PASS: gdb.base/gnu-debugdata.exp: nm - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm - invoke sort +PASS: gdb.base/gnu-debugdata.exp: comm +PASS: gdb.base/gnu-debugdata.exp: objcopy 1 +PASS: gdb.base/gnu-debugdata.exp: strip +PASS: gdb.base/gnu-debugdata.exp: copydebug +PASS: gdb.base/gnu-debugdata.exp: addlink +PASS: gdb.base/gnu-debugdata.exp: xz +PASS: gdb.base/gnu-debugdata.exp: objcopy 2 +PASS: gdb.base/gnu-debugdata.exp: no symtab +PASS: gdb.base/gnu-debugdata.exp: have symtab +PASS: gdb.base/gnu-debugdata.exp: unload MiniDebugInfo +Running ./gdb.base/gnu-ifunc.exp ... +gdb compile failed, /tmp/cctHw26J.s: Assembler messages: +/tmp/cctHw26J.s:42: Error: unrecognized symbol type "" +UNTESTED: gdb.base/gnu-ifunc.exp: Could not compile dynamic executable /var/tmp/portage/cross-armv7a-cros-linux-gnueabi/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.base/gnu-ifunc. +Running ./gdb.base/gnu_vector.exp ... +PASS: gdb.base/gnu_vector.exp: print c4 +PASS: gdb.base/gnu_vector.exp: print c4[2] +PASS: gdb.base/gnu_vector.exp: print i4a +PASS: gdb.base/gnu_vector.exp: print i4b +PASS: gdb.base/gnu_vector.exp: print i4a + i4b +PASS: gdb.base/gnu_vector.exp: print i4a - i4b +PASS: gdb.base/gnu_vector.exp: print i4a * i4b +PASS: gdb.base/gnu_vector.exp: print i4a / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % i4b +PASS: gdb.base/gnu_vector.exp: print i4a++ +PASS: gdb.base/gnu_vector.exp: print ++i4a +PASS: gdb.base/gnu_vector.exp: print i4a-- +PASS: gdb.base/gnu_vector.exp: print --i4a +PASS: gdb.base/gnu_vector.exp: print +i4a +PASS: gdb.base/gnu_vector.exp: print -i4a +PASS: gdb.base/gnu_vector.exp: print i4a & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | i4b +PASS: gdb.base/gnu_vector.exp: print i4a ^ i4b +PASS: gdb.base/gnu_vector.exp: print ~i4a +PASS: gdb.base/gnu_vector.exp: print i4a << i4b +PASS: gdb.base/gnu_vector.exp: print i4a >> i4b +PASS: gdb.base/gnu_vector.exp: print f4a +PASS: gdb.base/gnu_vector.exp: print f4b +PASS: gdb.base/gnu_vector.exp: print f4a + f4b +PASS: gdb.base/gnu_vector.exp: print f4a - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * f4b +PASS: gdb.base/gnu_vector.exp: print f4a / f4b +PASS: gdb.base/gnu_vector.exp: print +f4a +PASS: gdb.base/gnu_vector.exp: print -f4a +PASS: gdb.base/gnu_vector.exp: print (char4) 0x01010101 +PASS: gdb.base/gnu_vector.exp: print (char4) ia +PASS: gdb.base/gnu_vector.exp: print (int2) lla +PASS: gdb.base/gnu_vector.exp: print (int2) 1 +PASS: gdb.base/gnu_vector.exp: print (longlong2) 2 +PASS: gdb.base/gnu_vector.exp: print (float2) 3 +PASS: gdb.base/gnu_vector.exp: print (double2) 4 +PASS: gdb.base/gnu_vector.exp: print (uint4) ia +PASS: gdb.base/gnu_vector.exp: print (int4) -3 +PASS: gdb.base/gnu_vector.exp: print (float4) 4 +PASS: gdb.base/gnu_vector.exp: print i4b = ia +PASS: gdb.base/gnu_vector.exp: print i4a = 3 +PASS: gdb.base/gnu_vector.exp: print f4a = fb +PASS: gdb.base/gnu_vector.exp: print f4b = 2 +PASS: gdb.base/gnu_vector.exp: print c4 + lla +PASS: gdb.base/gnu_vector.exp: print i4a + lla +PASS: gdb.base/gnu_vector.exp: print lla + c4 +PASS: gdb.base/gnu_vector.exp: print lla + i4a +PASS: gdb.base/gnu_vector.exp: print c4 + ib +PASS: gdb.base/gnu_vector.exp: print i4a + ib +PASS: gdb.base/gnu_vector.exp: print i4a + 1 +PASS: gdb.base/gnu_vector.exp: print 1 + i4a +PASS: gdb.base/gnu_vector.exp: print fa - f4b +PASS: gdb.base/gnu_vector.exp: print 2 - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * fb +PASS: gdb.base/gnu_vector.exp: print f4a * 1 +PASS: gdb.base/gnu_vector.exp: print ia / i4b +PASS: gdb.base/gnu_vector.exp: print 2 / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % ib +PASS: gdb.base/gnu_vector.exp: print i4a % 1 +PASS: gdb.base/gnu_vector.exp: print ia & i4b +PASS: gdb.base/gnu_vector.exp: print 2 & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | ib +PASS: gdb.base/gnu_vector.exp: print i4a | 1 +PASS: gdb.base/gnu_vector.exp: print ia ^ i4b +PASS: gdb.base/gnu_vector.exp: print 2 ^ i4b +PASS: gdb.base/gnu_vector.exp: print i4a << ib +PASS: gdb.base/gnu_vector.exp: print i4a << 1 +PASS: gdb.base/gnu_vector.exp: print i4a >> ib +PASS: gdb.base/gnu_vector.exp: print i4a >> 1 +PASS: gdb.base/gnu_vector.exp: print i4a = {2, 4, 8, 16} +PASS: gdb.base/gnu_vector.exp: print i4a <<= ib +PASS: gdb.base/gnu_vector.exp: print i4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + f4a +PASS: gdb.base/gnu_vector.exp: print i2 + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i2 +PASS: gdb.base/gnu_vector.exp: print i4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + f4a +PASS: gdb.base/gnu_vector.exp: print ui4 + i4a +PASS: gdb.base/gnu_vector.exp: print i4a + ui4 +PASS: gdb.base/gnu_vector.exp: print i4a + i2 +PASS: gdb.base/gnu_vector.exp: print i2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + f2 +PASS: gdb.base/gnu_vector.exp: print f2 + f4a +PASS: gdb.base/gnu_vector.exp: print (double2) f2 +PASS: gdb.base/gnu_vector.exp: print (int4) c4 +PASS: gdb.base/gnu_vector.exp: print (char4) i4a +PASS: gdb.base/gnu_vector.exp: ptype c4 +PASS: gdb.base/gnu_vector.exp: ptype char4 +PASS: gdb.base/gnu_vector.exp: ptype i4a +PASS: gdb.base/gnu_vector.exp: ptype int4 +PASS: gdb.base/gnu_vector.exp: ptype f4b +PASS: gdb.base/gnu_vector.exp: ptype float4 +PASS: gdb.base/gnu_vector.exp: ptype union_with_vector_1 +PASS: gdb.base/gnu_vector.exp: ptype struct_with_vector_1 +Running ./gdb.base/hashline1.exp ... +PASS: gdb.base/hashline1.exp: set breakpoint +Running ./gdb.base/hashline2.exp ... +PASS: gdb.base/hashline2.exp: set breakpoint +Running ./gdb.base/hashline3.exp ... +PASS: gdb.base/hashline3.exp: set breakpoint +Running ./gdb.base/hbreak2.exp ... +PASS: gdb.base/hbreak2.exp: hardware breakpoint support +FAIL: gdb.base/hbreak2.exp: hardware breakpoint insertion +PASS: gdb.base/hbreak2.exp: hardware breakpoint function +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: use `list' to establish default source file +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line if conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line while conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint info +PASS: gdb.base/hbreak2.exp: hardware breakpoint function (2) +FAIL: gdb.base/hbreak2.exp: run until function breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number (2) +PASS: gdb.base/hbreak2.exp: run until breakpoint set at a line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file (2) +PASS: gdb.base/hbreak2.exp: run until file:function(6) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(5) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(4) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(3) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(2) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(1) breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function (2) +PASS: gdb.base/hbreak2.exp: run until quoted breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file (2) +PASS: gdb.base/hbreak2.exp: run until file:linenum breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint offset +1 +PASS: gdb.base/hbreak2.exp: step onto hardware breakpoint +PASS: gdb.base/hbreak2.exp: setting hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: continue to hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint info +PASS: gdb.base/hbreak2.exp: set breakpoint pending off +PASS: gdb.base/hbreak2.exp: hardware break on non-existent source line +PASS: gdb.base/hbreak2.exp: until bp_location1 +PASS: gdb.base/hbreak2.exp: hardware break on default location +PASS: gdb.base/hbreak2.exp: set to-be-silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: set silent break bp_location1 +PASS: gdb.base/hbreak2.exp: info silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: hit silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: stopped for silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on non-existent thread disallowed +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on bogus thread ID disallowed +PASS: gdb.base/hbreak2.exp: hardware breakpoint with trailing garbage disallowed +PASS: gdb.base/hbreak2.exp: step over hardware breakpoint +PASS: gdb.base/hbreak2.exp: clear line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via convenience variable +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/hbreak2.exp: set hardware breakpoint on to-be-called function +PASS: gdb.base/hbreak2.exp: hit hardware breakpoint on called function +PASS: gdb.base/hbreak2.exp: backtrace while in called function +PASS: gdb.base/hbreak2.exp: finish from called function +PASS: gdb.base/hbreak2.exp: hardware break at factorial +PASS: gdb.base/hbreak2.exp: kill program +PASS: gdb.base/hbreak2.exp: run to factorial(6) +PASS: gdb.base/hbreak2.exp: continue to factorial(5) +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5) +PASS: gdb.base/hbreak2.exp: next to recursive call +PASS: gdb.base/hbreak2.exp: next over recursive call +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5.1) +FAIL: gdb.base/hbreak2.exp: setting breakpoint at exit +PASS: gdb.base/hbreak2.exp: hardware breakpoint function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware function breakpoint, optimized file (code motion) +PASS: gdb.base/hbreak2.exp: hardware breakpoint small function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware breakpoint set at small function, optimized file +Running ./gdb.base/hbreak.exp ... +Running ./gdb.base/help.exp ... +PASS: gdb.base/help.exp: disable pagination +PASS: gdb.base/help.exp: help aliases +PASS: gdb.base/help.exp: help breakpoints +PASS: gdb.base/help.exp: help data +PASS: gdb.base/help.exp: help files +PASS: gdb.base/help.exp: help internals +PASS: gdb.base/help.exp: help obscure +PASS: gdb.base/help.exp: help running +PASS: gdb.base/help.exp: help stack +PASS: gdb.base/help.exp: help status +PASS: gdb.base/help.exp: help support +PASS: gdb.base/help.exp: help tracepoints +PASS: gdb.base/help.exp: help user-defined +PASS: gdb.base/help.exp: help breakpoint "b" abbreviation +PASS: gdb.base/help.exp: help breakpoint "br" abbreviation +PASS: gdb.base/help.exp: help breakpoint "bre" abbreviation +PASS: gdb.base/help.exp: help breakpoint "brea" abbreviation +PASS: gdb.base/help.exp: help breakpoint "break" abbreviation +PASS: gdb.base/help.exp: help backtrace "bt" abbreviation +PASS: gdb.base/help.exp: help backtrace +PASS: gdb.base/help.exp: help commands +PASS: gdb.base/help.exp: help delete "d" abbreviation +PASS: gdb.base/help.exp: help delete +PASS: gdb.base/help.exp: help help "h" abbreviation +PASS: gdb.base/help.exp: help help +PASS: gdb.base/help.exp: help show copying +PASS: gdb.base/help.exp: help show warranty +PASS: gdb.base/help.exp: help show commands +PASS: gdb.base/help.exp: help show confirm +PASS: gdb.base/help.exp: help info bogus-gdb-command +PASS: gdb.base/help.exp: help gotcha +PASS: gdb.base/help.exp: apropos \(print[^ bsiedf\".-]\) +PASS: gdb.base/help.exp: apropos handle signal +PASS: gdb.base/help.exp: apropos apropos +Running ./gdb.base/hook-stop-continue.exp ... +PASS: gdb.base/hook-stop-continue.exp: breakpoint line number +PASS: gdb.base/hook-stop-continue.exp: print $do_continue = 1 +PASS: gdb.base/hook-stop-continue.exp: define hook-stop command +PASS: gdb.base/hook-stop-continue.exp: next triggering hook-stop +PASS: gdb.base/hook-stop-continue.exp: next no hook-stop +Running ./gdb.base/hook-stop-frame.exp ... +PASS: gdb.base/hook-stop-frame.exp: breakpoint line number +PASS: gdb.base/hook-stop-frame.exp: define hook-stop command +PASS: gdb.base/hook-stop-frame.exp: hook-stop runs before frame print +Running ./gdb.base/huge.exp ... +PASS: gdb.base/huge.exp: print a very large data object +Running ./gdb.base/ifelse.exp ... +PASS: gdb.base/ifelse.exp: if 1 with empty body +PASS: gdb.base/ifelse.exp: if 0 with empty body +PASS: gdb.base/ifelse.exp: if true else false #1 +PASS: gdb.base/ifelse.exp: if 1 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #2 +PASS: gdb.base/ifelse.exp: if 0 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #3 +PASS: gdb.base/ifelse.exp: create define with empty else +PASS: gdb.base/ifelse.exp: call original define +PASS: gdb.base/ifelse.exp: replace define with if .. else with empty body +PASS: gdb.base/ifelse.exp: call replacement define +Running ./gdb.base/included.exp ... +PASS: gdb.base/included.exp: set listsize 1 +PASS: gdb.base/included.exp: list main +PASS: gdb.base/included.exp: list integer +PASS: gdb.base/included.exp: ptype integer +PASS: gdb.base/included.exp: info variables integer +Running ./gdb.base/inferior-died.exp ... +UNSUPPORTED: gdb.base/inferior-died.exp: inferior-died.exp +Running ./gdb.base/infnan.exp ... +PASS: gdb.base/infnan.exp: print a +PASS: gdb.base/infnan.exp: print b +Running ./gdb.base/info-fun.exp ... +Running ./gdb.base/infoline.exp ... +PASS: gdb.base/infoline.exp: info line infoline.c:18 +Running ./gdb.base/info-macros.exp ... +FAIL: gdb.base/info-macros.exp: info macro -- -all +FAIL: gdb.base/info-macros.exp: info macro -- -all +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -- +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: info macro -invalid-option 1 +PASS: gdb.base/info-macros.exp: info macro -invalid-option +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro -a FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -all -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macros 2 +FAIL: gdb.base/info-macros.exp: info macros 3 +FAIL: gdb.base/info-macros.exp: info macros 4 +FAIL: gdb.base/info-macros.exp: info macros *$pc +FAIL: gdb.base/info-macros.exp: info macros +FAIL: gdb.base/info-macros.exp: info macros 6 +FAIL: gdb.base/info-macros.exp: info macros 7 +KFAIL: gdb.base/info-macros.exp: info macros info-macros.c:42 (PRMS: gdb/NNNN) +Running ./gdb.base/info-os.exp ... +PASS: gdb.base/info-os.exp: get inferior process ID +PASS: gdb.base/info-os.exp: continue to breakpoint: Set breakpoint here +PASS: gdb.base/info-os.exp: get shared memory key +PASS: gdb.base/info-os.exp: get shared memory ID +PASS: gdb.base/info-os.exp: get semaphore key +PASS: gdb.base/info-os.exp: get semaphore ID +PASS: gdb.base/info-os.exp: get message queue key +PASS: gdb.base/info-os.exp: get message queue ID +PASS: gdb.base/info-os.exp: get socket port number +PASS: gdb.base/info-os.exp: get process list +PASS: gdb.base/info-os.exp: get process groups +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get file descriptors +PASS: gdb.base/info-os.exp: get internet-domain sockets +PASS: gdb.base/info-os.exp: get shared-memory regions +PASS: gdb.base/info-os.exp: get semaphores +PASS: gdb.base/info-os.exp: get message queues +PASS: gdb.base/info-os.exp: continue +Running ./gdb.base/info-proc.exp ... +PASS: gdb.base/info-proc.exp: help info proc +PASS: gdb.base/info-proc.exp: info proc without a process +PASS: gdb.base/info-proc.exp: info proc with process +PASS: gdb.base/info-proc.exp: info proc mapping +PASS: gdb.base/info-proc.exp: save a core file +PASS: gdb.base/info-proc.exp: core break.gcore +PASS: gdb.base/info-proc.exp: info proc mapping with core file +Running ./gdb.base/info-target.exp ... +PASS: gdb.base/info-target.exp: info target +Running ./gdb.base/interact.exp ... +PASS: gdb.base/interact.exp: set interactive-mode auto +PASS: gdb.base/interact.exp: source script with interactive-mode auto +PASS: gdb.base/interact.exp: sanity check with interactive-mode auto +PASS: gdb.base/interact.exp: show interactive-mode (auto) +PASS: gdb.base/interact.exp: set interactive-mode on +PASS: gdb.base/interact.exp: source script with interactive-mode on +PASS: gdb.base/interact.exp: sanity check with interactive-mode on +PASS: gdb.base/interact.exp: show interactive-mode (on) +PASS: gdb.base/interact.exp: set interactive-mode off +PASS: gdb.base/interact.exp: source script with interactive-mode off +PASS: gdb.base/interact.exp: sanity check with interactive-mode off +PASS: gdb.base/interact.exp: show interactive-mode (off) +Running ./gdb.base/interp.exp ... +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec console "show version" +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec mi "-stack-info-frame" +PASS: gdb.base/interp.exp: interpreter-exec mi1 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi2 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi3 "-break-insert main" +PASS: gdb.base/interp.exp: can list sources +Running ./gdb.base/interrupt.exp ... +Running ./gdb.base/jit.exp ... +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-1: set var argc = 2 +FAIL: gdb.base/jit.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +FAIL: gdb.base/jit.exp: one_jit_test-1: set var count = 1 +FAIL: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 1 +FAIL: gdb.base/jit.exp: one_jit_test-1: info function jit_function +FAIL: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-2: set var argc = 2 +FAIL: gdb.base/jit.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +FAIL: gdb.base/jit.exp: one_jit_test-2: set var count = 2 +FAIL: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 1 +FAIL: gdb.base/jit.exp: one_jit_test-2: info function jit_function +FAIL: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var argc = 2 +FAIL: gdb.base/jit.exp: PIE: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +FAIL: gdb.base/jit.exp: PIE: one_jit_test-1: set var count = 1 +FAIL: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 1 +FAIL: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +FAIL: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +Running ./gdb.base/jit-simple.exp ... +PASS: gdb.base/jit-simple.exp: blah 1 +PASS: gdb.base/jit-simple.exp: recompile jit-simple.c +PASS: gdb.base/jit-simple.exp: blah 1 +Running ./gdb.base/jit-so.exp ... +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here before-dlopen +FAIL: gdb.base/jit-so.exp: one_jit_test-1: set var jit_libname = "jit-main.so" +FAIL: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here after-dlopen +FAIL: gdb.base/jit-so.exp: one_jit_test-1: setting breakpoint at jit-main.c:131 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 0 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: set var argc = 2 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +FAIL: gdb.base/jit-so.exp: one_jit_test-1: set var count = 1 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: setting breakpoint at jit-main.c:194 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 1 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +FAIL: gdb.base/jit-so.exp: one_jit_test-1: setting breakpoint at jit-main.c:219 +FAIL: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here before-dlopen +FAIL: gdb.base/jit-so.exp: one_jit_test-2: set var jit_libname = "jit-main.so" +FAIL: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here after-dlopen +FAIL: gdb.base/jit-so.exp: one_jit_test-2: setting breakpoint at jit-main.c:131 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 0 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: set var argc = 2 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +FAIL: gdb.base/jit-so.exp: one_jit_test-2: set var count = 2 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: setting breakpoint at jit-main.c:194 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 1 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +FAIL: gdb.base/jit-so.exp: one_jit_test-2: setting breakpoint at jit-main.c:219 +FAIL: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +Running ./gdb.base/jump.exp ... +PASS: gdb.base/jump.exp: break before jump to non-call +PASS: gdb.base/jump.exp: jump to non-call +PASS: gdb.base/jump.exp: break before jump to call +PASS: gdb.base/jump.exp: jump to call +PASS: gdb.base/jump.exp: disable breakpoint on call +PASS: gdb.base/jump.exp: jump to call with disabled breakpoint +PASS: gdb.base/jump.exp: jump without argument disallowed +PASS: gdb.base/jump.exp: jump with trailing argument junk +PASS: gdb.base/jump.exp: aborted jump out of current function +PASS: gdb.base/jump.exp: jump out of current function +Running ./gdb.base/kill-after-signal.exp ... +UNTESTED: gdb.base/kill-after-signal.exp: kill-after-signal.exp +Running ./gdb.base/label.exp ... +Running ./gdb.base/langs.exp ... +PASS: gdb.base/langs.exp: break on nonexistent function in langs.exp +PASS: gdb.base/langs.exp: show language at csub in langs.exp +PASS: gdb.base/langs.exp: backtrace in langs.exp +PASS: gdb.base/langs.exp: up to foo in langs.exp +PASS: gdb.base/langs.exp: show language at foo in langs.exp +PASS: gdb.base/langs.exp: up to cppsub_ in langs.exp +PASS: gdb.base/langs.exp: show language at cppsub_ in langs.exp +PASS: gdb.base/langs.exp: up to fsub in langs.exp +PASS: gdb.base/langs.exp: show language at fsub in langs.exp +PASS: gdb.base/langs.exp: up to langs0__2do in langs.exp +PASS: gdb.base/langs.exp: show language at langs0__2do in langs.exp +PASS: gdb.base/langs.exp: up to main in langs.exp +PASS: gdb.base/langs.exp: show language at main in langs.exp +FAIL: gdb.base/langs.exp: setting breakpoint at exit +PASS: gdb.base/langs.exp: set lang to minimal +PASS: gdb.base/langs.exp: print parameter value +Running ./gdb.base/ldbl_e308.exp ... +PASS: gdb.base/ldbl_e308.exp: set variable ldbl_308 = 1.6e+308l +PASS: gdb.base/ldbl_e308.exp: print ldbl_308 +Running ./gdb.base/lineinc.exp ... +PASS: gdb.base/lineinc.exp: tolerate macro info with multiple #inclusions per line +Running ./gdb.base/linespecs.exp ... +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c +Running ./gdb.base/list.exp ... +PASS: gdb.base/list.exp: set width 0 +PASS: gdb.base/list.exp: show default list size +PASS: gdb.base/list.exp: list default lines around main +PASS: gdb.base/list.exp: setting listsize to 1 #1 +PASS: gdb.base/list.exp: show listsize 1 #1 +PASS: gdb.base/list.exp: list line 1 with listsize 1 +PASS: gdb.base/list.exp: list line 2 with listsize 1 +PASS: gdb.base/list.exp: setting listsize to 2 #2 +PASS: gdb.base/list.exp: show listsize 2 #2 +PASS: gdb.base/list.exp: list line 1 with listsize 2 +PASS: gdb.base/list.exp: list line 2 with listsize 2 +PASS: gdb.base/list.exp: list line 3 with listsize 2 +PASS: gdb.base/list.exp: setting listsize to 3 #3 +PASS: gdb.base/list.exp: show listsize 3 #3 +PASS: gdb.base/list.exp: list line 1 with listsize 3 +PASS: gdb.base/list.exp: list line 2 with listsize 3 +PASS: gdb.base/list.exp: list line 3 with listsize 3 +PASS: gdb.base/list.exp: setting listsize to 4 #4 +PASS: gdb.base/list.exp: show listsize 4 #4 +PASS: gdb.base/list.exp: list line 1 with listsize 4 +PASS: gdb.base/list.exp: list line 2 with listsize 4 +PASS: gdb.base/list.exp: list line 3 with listsize 4 +PASS: gdb.base/list.exp: list line 4 with listsize 4 +PASS: gdb.base/list.exp: setting listsize to 100 #5 +PASS: gdb.base/list.exp: show listsize 100 #5 +PASS: gdb.base/list.exp: list line 1 with listsize 100 +PASS: gdb.base/list.exp: list line 10 with listsize 100 +PASS: gdb.base/list.exp: setting listsize to 0 #6 +PASS: gdb.base/list.exp: show listsize unlimited #6 +PASS: gdb.base/list.exp: list line 1 with unlimited listsize +PASS: gdb.base/list.exp: setting listsize to 10 #7 +PASS: gdb.base/list.exp: show listsize 10 #7 +PASS: gdb.base/list.exp: list line 1 in include file +PASS: gdb.base/list.exp: list message for lines past EOF +PASS: gdb.base/list.exp: list filename:number (4 tests) +PASS: gdb.base/list.exp: list function in source file 1 +PASS: gdb.base/list.exp: list function in source file 2 +PASS: gdb.base/list.exp: list function in include file +PASS: gdb.base/list.exp: successive list commands to page forward (4 tests) +PASS: gdb.base/list.exp: 4 successive "list -" commands to page backwards +PASS: gdb.base/list.exp: repeat list commands to page forward using 'return' (4 tests) +PASS: gdb.base/list.exp: list range; filename:line1,filename:line2 +PASS: gdb.base/list.exp: list range; line1,line2 +PASS: gdb.base/list.exp: list range; upper bound past EOF +PASS: gdb.base/list.exp: list range; both bounds past EOF +PASS: gdb.base/list.exp: list range, must be same files +PASS: gdb.base/list.exp: list filename:function (5 tests) +PASS: gdb.base/list.exp: list 'list0.c:main' +XFAIL: gdb.base/list.exp: list filename:function; wrong filename rejected +PASS: gdb.base/list.exp: list filename:function; nonexistant file +PASS: gdb.base/list.exp: list filename:function; nonexistant function +PASS: gdb.base/list.exp: set listsize 4 +PASS: gdb.base/list.exp: list long_line +PASS: gdb.base/list.exp: search 4321 +PASS: gdb.base/list.exp: search 6789 +PASS: gdb.base/list.exp: search extremely long line (> 5000 chars) +PASS: gdb.base/list.exp: set listsize 2 +PASS: gdb.base/list.exp: list 1 +PASS: gdb.base/list.exp: list ,5 +Running ./gdb.base/logical.exp ... +PASS: gdb.base/logical.exp: evaluate x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 3, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 1, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 2, y = 2, w = 2, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +Running ./gdb.base/longest-types.exp ... +UNTESTED: gdb.base/longest-types.exp: longest-types.exp +Running ./gdb.base/longjmp.exp ... +PASS: gdb.base/longjmp.exp: breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_1 +PASS: gdb.base/longjmp.exp: next over setjmp (1) +PASS: gdb.base/longjmp.exp: next to longjmp (1) +FAIL: gdb.base/longjmp.exp: next over longjmp(1) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_2 +PASS: gdb.base/longjmp.exp: next over setjmp (2) +FAIL: gdb.base/longjmp.exp: next over call_longjmp (2) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 3 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 3 start +PASS: gdb.base/longjmp.exp: next over patt3 +Running ./gdb.base/long_long.exp ... +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (char)" (1) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (short)" (2) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (int)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long long)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (void *)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (double)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long double)" (8) +PASS: gdb.base/long_long.exp: continue to breakpoint: Stop here and look +PASS: gdb.base/long_long.exp: hex print p/x +PASS: gdb.base/long_long.exp: decimal print p/x +PASS: gdb.base/long_long.exp: default print val.dec +PASS: gdb.base/long_long.exp: default print val.bin +PASS: gdb.base/long_long.exp: default print val.oct +PASS: gdb.base/long_long.exp: default print hex +PASS: gdb.base/long_long.exp: decimal print p/u +PASS: gdb.base/long_long.exp: binary print +PASS: gdb.base/long_long.exp: octal print +PASS: gdb.base/long_long.exp: print +ve long long +PASS: gdb.base/long_long.exp: decimal print p/d +PASS: gdb.base/long_long.exp: p/d val.oct +PASS: gdb.base/long_long.exp: p/u val.oct +PASS: gdb.base/long_long.exp: p/o val.oct +PASS: gdb.base/long_long.exp: p/t val.oct +PASS: gdb.base/long_long.exp: p/a val.oct +PASS: gdb.base/long_long.exp: p/c val.oct +PASS: gdb.base/long_long.exp: p/f val.oct +PASS: gdb.base/long_long.exp: p/x *(char *)c +PASS: gdb.base/long_long.exp: p/d *(char *)c +PASS: gdb.base/long_long.exp: p/u *(char *)c +PASS: gdb.base/long_long.exp: p/o *(char *)c +PASS: gdb.base/long_long.exp: p/t *(char *)c +PASS: gdb.base/long_long.exp: p/a *(char *)c +PASS: gdb.base/long_long.exp: p/f *(char *)c +PASS: gdb.base/long_long.exp: p/c *(char *)c +PASS: gdb.base/long_long.exp: p/x *(short *)s +PASS: gdb.base/long_long.exp: p/d *(short *)s +PASS: gdb.base/long_long.exp: p/u *(short *)s +PASS: gdb.base/long_long.exp: p/o *(short *)s +PASS: gdb.base/long_long.exp: p/t *(short *)s +PASS: gdb.base/long_long.exp: p/a *(short *)s +PASS: gdb.base/long_long.exp: p/f *(short *)s +PASS: gdb.base/long_long.exp: p/c *(short *)s +PASS: gdb.base/long_long.exp: p/x *(int *)i +PASS: gdb.base/long_long.exp: p/d *(int *)i +PASS: gdb.base/long_long.exp: p/u *(int *)i +PASS: gdb.base/long_long.exp: p/o *(int *)i +PASS: gdb.base/long_long.exp: p/t *(int *)i +PASS: gdb.base/long_long.exp: p/a *(int *)i +PASS: gdb.base/long_long.exp: p/f *(int *)i +PASS: gdb.base/long_long.exp: p/c *(int *)i +PASS: gdb.base/long_long.exp: p/x *(long *)l +PASS: gdb.base/long_long.exp: p/d *(long *)l +PASS: gdb.base/long_long.exp: p/u *(long *)l +PASS: gdb.base/long_long.exp: p/o *(long *)l +PASS: gdb.base/long_long.exp: p/t *(long *)l +PASS: gdb.base/long_long.exp: p/a *(long *)l +PASS: gdb.base/long_long.exp: p/f *(long *)l +PASS: gdb.base/long_long.exp: p/c *(long *)l +PASS: gdb.base/long_long.exp: p/x *(long long *)ll +PASS: gdb.base/long_long.exp: p/d *(long long *)ll +PASS: gdb.base/long_long.exp: p/u *(long long *)ll +PASS: gdb.base/long_long.exp: p/o *(long long *)ll +PASS: gdb.base/long_long.exp: p/t *(long long *)ll +PASS: gdb.base/long_long.exp: p/a *(long long *)ll +PASS: gdb.base/long_long.exp: p/f *(long long *)ll +PASS: gdb.base/long_long.exp: p/c *(long long *)ll +PASS: gdb.base/long_long.exp: set examine size to w +PASS: gdb.base/long_long.exp: x/x w +PASS: gdb.base/long_long.exp: x/d w +PASS: gdb.base/long_long.exp: x/u w +PASS: gdb.base/long_long.exp: x/o w +PASS: gdb.base/long_long.exp: x/t w +PASS: gdb.base/long_long.exp: x/a +PASS: gdb.base/long_long.exp: x/c b +PASS: gdb.base/long_long.exp: x/f &val.oct +PASS: gdb.base/long_long.exp: set examine size to g +PASS: gdb.base/long_long.exp: x/2x g +PASS: gdb.base/long_long.exp: x/2d g +PASS: gdb.base/long_long.exp: x/2u g +PASS: gdb.base/long_long.exp: x/2o g +PASS: gdb.base/long_long.exp: x/2t g +PASS: gdb.base/long_long.exp: x/2a +PASS: gdb.base/long_long.exp: x/2c b +PASS: gdb.base/long_long.exp: x/2f &val.oct +PASS: gdb.base/long_long.exp: x/2bx b +PASS: gdb.base/long_long.exp: x/2bd b +PASS: gdb.base/long_long.exp: x/2bu b +PASS: gdb.base/long_long.exp: x/2bo b +PASS: gdb.base/long_long.exp: x/2bt b +PASS: gdb.base/long_long.exp: x/2ba b +PASS: gdb.base/long_long.exp: x/2bc b +PASS: gdb.base/long_long.exp: x/2bf b +PASS: gdb.base/long_long.exp: x/2hx h +PASS: gdb.base/long_long.exp: x/2hd h +PASS: gdb.base/long_long.exp: x/2hu h +PASS: gdb.base/long_long.exp: x/2ho h +PASS: gdb.base/long_long.exp: x/2ht h +PASS: gdb.base/long_long.exp: x/2ha h +PASS: gdb.base/long_long.exp: x/2hc h +PASS: gdb.base/long_long.exp: x/2hf h +PASS: gdb.base/long_long.exp: x/2wx w +PASS: gdb.base/long_long.exp: x/2wd w +PASS: gdb.base/long_long.exp: x/2wu w +PASS: gdb.base/long_long.exp: x/2wo w +PASS: gdb.base/long_long.exp: x/2wt w +PASS: gdb.base/long_long.exp: x/2wa w +PASS: gdb.base/long_long.exp: x/2wc w +PASS: gdb.base/long_long.exp: x/2wf w +PASS: gdb.base/long_long.exp: x/2gx g +PASS: gdb.base/long_long.exp: x/2gd g +PASS: gdb.base/long_long.exp: x/2gu g +PASS: gdb.base/long_long.exp: x/2go g +PASS: gdb.base/long_long.exp: x/2gt g +PASS: gdb.base/long_long.exp: x/2ga g +PASS: gdb.base/long_long.exp: x/2gc g +PASS: gdb.base/long_long.exp: x/2gf g +Running ./gdb.base/macscp.exp ... +PASS: gdb.base/macscp.exp: list main for support check +UNSUPPORTED: gdb.base/macscp.exp: Skipping test because debug information does not include macro information. +Running ./gdb.base/maint.exp ... +PASS: gdb.base/maint.exp: set height 0 +PASS: gdb.base/maint.exp: maint print registers +PASS: gdb.base/maint.exp: maint check-symtabs +PASS: gdb.base/maint.exp: maint space +PASS: gdb.base/maint.exp: maint space 1 +PASS: gdb.base/maint.exp: maint time +PASS: gdb.base/maint.exp: maint time 1 +PASS: gdb.base/maint.exp: maint time 0 +PASS: gdb.base/maint.exp: maint space 0 +PASS: gdb.base/maint.exp: maint demangle +PASS: gdb.base/maint.exp: maint demangle main +PASS: gdb.base/maint.exp: maint print statistics +PASS: gdb.base/maint.exp: maint print dummy-frames +PASS: gdb.base/maint.exp: maint print objfiles: header +PASS: gdb.base/maint.exp: maint print objfiles: psymtabs +PASS: gdb.base/maint.exp: maint print objfiles: symtabs +PASS: gdb.base/maint.exp: maint print psymbols w/o args +PASS: gdb.base/maint.exp: maint print psymbols 1 +PASS: gdb.base/maint.exp: shell rm -f psymbols_output +PASS: gdb.base/maint.exp: maint print msymbols w/o args +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output +PASS: gdb.base/maint.exp: cd to objdir +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output2 +PASS: gdb.base/maint.exp: cd to mydir +PASS: gdb.base/maint.exp: maint print symbols w/o args +PASS: gdb.base/maint.exp: maint print symbols +PASS: gdb.base/maint.exp: shell rm -f symbols_output +PASS: gdb.base/maint.exp: maint print type +PASS: gdb.base/maint.exp: maint info sections +PASS: gdb.base/maint.exp: maint info sections .text +PASS: gdb.base/maint.exp: maint info sections CODE +PASS: gdb.base/maint.exp: maint info sections DATA +FAIL: gdb.base/maint.exp: maint info breakpoints +PASS: gdb.base/maint.exp: maint print w/o args +PASS: gdb.base/maint.exp: maint info w/o args +PASS: gdb.base/maint.exp: maint w/o args +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: help maint check-symtabs +PASS: gdb.base/maint.exp: help maint space +PASS: gdb.base/maint.exp: help maint time +PASS: gdb.base/maint.exp: help maint demangle +PASS: gdb.base/maint.exp: help maint dump-me +PASS: gdb.base/maint.exp: help maint internal-error +PASS: gdb.base/maint.exp: help maint internal-warning +PASS: gdb.base/maint.exp: help maint print statistics +PASS: gdb.base/maint.exp: help maint print dummy-frames +PASS: gdb.base/maint.exp: help maint print objfiles +PASS: gdb.base/maint.exp: help maint print psymbols +PASS: gdb.base/maint.exp: help maint print msymbols +PASS: gdb.base/maint.exp: help maint print symbols +PASS: gdb.base/maint.exp: help maint print type +PASS: gdb.base/maint.exp: help maint info sections +PASS: gdb.base/maint.exp: help maint info breakpoints +PASS: gdb.base/maint.exp: help maint info +PASS: gdb.base/maint.exp: help maint print +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: maint dump-me +PASS: gdb.base/maint.exp: maint internal-error +PASS: gdb.base/maint.exp: internal-error resync +Running ./gdb.base/memattr.exp ... +PASS: gdb.base/memattr.exp: create mem region 1 +PASS: gdb.base/memattr.exp: create mem region 2 +PASS: gdb.base/memattr.exp: create mem region 3 +PASS: gdb.base/memattr.exp: create mem region 4 +PASS: gdb.base/memattr.exp: create mem region 5 +PASS: gdb.base/memattr.exp: info mem (1) +PASS: gdb.base/memattr.exp: mem1 cannot be read +PASS: gdb.base/memattr.exp: mem1 can be written +PASS: gdb.base/memattr.exp: mem2 cannot be written +PASS: gdb.base/memattr.exp: mem2 can be read +PASS: gdb.base/memattr.exp: disable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was disabled +PASS: gdb.base/memattr.exp: enable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was enabled +PASS: gdb.base/memattr.exp: disable mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were disabled +PASS: gdb.base/memattr.exp: enable mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were enabled +PASS: gdb.base/memattr.exp: disable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were disabled +PASS: gdb.base/memattr.exp: enable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were enabled +PASS: gdb.base/memattr.exp: disable non-existant regions +PASS: gdb.base/memattr.exp: delete mem 1 +PASS: gdb.base/memattr.exp: mem 1 was deleted +PASS: gdb.base/memattr.exp: delete mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were deleted +PASS: gdb.base/memattr.exp: delete mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were deleted +PASS: gdb.base/memattr.exp: delete non-existant region +PASS: gdb.base/memattr.exp: mem 0x30 0x60 ro +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x60 0x70: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x80 0x0: no-overlap +PASS: gdb.base/memattr.exp: mem 0x30 0x0 ro +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x00 0x10: no-overlap +Running ./gdb.base/mips_pro.exp ... +PASS: gdb.base/mips_pro.exp: backtrace +Running ./gdb.base/miscexprs.exp ... +PASS: gdb.base/miscexprs.exp: continue to marker1 +PASS: gdb.base/miscexprs.exp: up from marker1 +PASS: gdb.base/miscexprs.exp: print value of &ibig.i[0] +PASS: gdb.base/miscexprs.exp: print value of &cbig.c[0] +PASS: gdb.base/miscexprs.exp: print value of &fbig.f[0] +PASS: gdb.base/miscexprs.exp: print value of &dbig.d[0] +PASS: gdb.base/miscexprs.exp: print value of &sbig.s[0] +PASS: gdb.base/miscexprs.exp: print value of &lbig.l[0] +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] | 1 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] & 127 +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] * 10 +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] * sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of fbig.f[100] * dbig.d[202] +PASS: gdb.base/miscexprs.exp: print value of !(sbig.s[90] * 2) +PASS: gdb.base/miscexprs.exp: print value of sizeof sbig +PASS: gdb.base/miscexprs.exp: print value of sizeof cbig +PASS: gdb.base/miscexprs.exp: print value of sizeof lbig / sizeof long +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] << 2 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] >> 4 +PASS: gdb.base/miscexprs.exp: print value of lbig.l[333] >> 6 +Running ./gdb.base/morestack.exp ... +gdb compile failed, cc1: error: '-fsplit-stack' is not supported by this compiler configuration +UNTESTED: gdb.base/morestack.exp: morestack.exp +Running ./gdb.base/moribund-step.exp ... +PASS: gdb.base/moribund-step.exp: set non-stop on +Running ./gdb.base/multi-forks.exp ... +Running ./gdb.base/nextoverexit.exp ... +PASS: gdb.base/nextoverexit.exp: next over exit +Running ./gdb.base/nodebug.exp ... +PASS: gdb.base/nodebug.exp: p top +PASS: gdb.base/nodebug.exp: whatis top +PASS: gdb.base/nodebug.exp: ptype top +PASS: gdb.base/nodebug.exp: p middle +PASS: gdb.base/nodebug.exp: whatis middle +PASS: gdb.base/nodebug.exp: ptype middle +PASS: gdb.base/nodebug.exp: p dataglobal +PASS: gdb.base/nodebug.exp: whatis dataglobal +PASS: gdb.base/nodebug.exp: ptype dataglobal +PASS: gdb.base/nodebug.exp: p datalocal +PASS: gdb.base/nodebug.exp: whatis datalocal +PASS: gdb.base/nodebug.exp: ptype datalocal +PASS: gdb.base/nodebug.exp: p bssglobal +PASS: gdb.base/nodebug.exp: whatis bssglobal +PASS: gdb.base/nodebug.exp: ptype bssglobal +PASS: gdb.base/nodebug.exp: p bsslocal +PASS: gdb.base/nodebug.exp: whatis bsslocal +PASS: gdb.base/nodebug.exp: ptype bsslocal +PASS: gdb.base/nodebug.exp: backtrace from inner in nodebug.exp +FAIL: gdb.base/nodebug.exp: p/c array_index("abcdef",2) +PASS: gdb.base/nodebug.exp: backtrace from middle in nodebug.exp +Running ./gdb.base/nofield.exp ... +PASS: gdb.base/nofield.exp: ptype struct not_empty +PASS: gdb.base/nofield.exp: ptype struct empty +PASS: gdb.base/nofield.exp: ptype union empty_union +Running ./gdb.base/nostdlib.exp ... +UNTESTED: gdb.base/nostdlib.exp: nostdlib.exp +Running ./gdb.base/opaque.exp ... +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 2 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 2 +Running ./gdb.base/overlays.exp ... +Running ./gdb.base/page.exp ... +PASS: gdb.base/page.exp: set pagination off +PASS: gdb.base/page.exp: pagination is off +PASS: gdb.base/page.exp: unpaged help +PASS: gdb.base/page.exp: set pagination on +PASS: gdb.base/page.exp: pagination is on +PASS: gdb.base/page.exp: set height 10 +PASS: gdb.base/page.exp: paged help +PASS: gdb.base/page.exp: q +Running ./gdb.base/pc-fp.exp ... +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$pc" +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$fp" +PASS: gdb.base/pc-fp.exp: display/i $pc +PASS: gdb.base/pc-fp.exp: display/w $fp +PASS: gdb.base/pc-fp.exp: info register $pc +PASS: gdb.base/pc-fp.exp: info register $fp +PASS: gdb.base/pc-fp.exp: info register pc fp +Running ./gdb.base/pending.exp ... +PASS: gdb.base/pending.exp: set pending breakpoint (without symbols) +PASS: gdb.base/pending.exp: complete condition +PASS: gdb.base/pending.exp: single pending breakpoint info (without symbols) +FAIL: gdb.base/pending.exp: run to resolved breakpoint 1 (without symbols) (the program exited) +PASS: gdb.base/pending.exp: set pending breakpoint +PASS: gdb.base/pending.exp: single pending breakpoint info +PASS: gdb.base/pending.exp: breakpoint function +PASS: gdb.base/pending.exp: pending plus real breakpoint info +PASS: gdb.base/pending.exp: Don't set pending breakpoint +PASS: gdb.base/pending.exp: condition 1 k == 1 +PASS: gdb.base/pending.exp: pending plus condition +PASS: gdb.base/pending.exp: disable 1 +PASS: gdb.base/pending.exp: pending disabled +PASS: gdb.base/pending.exp: Set commands for pending breakpoint +PASS: gdb.base/pending.exp: pending disabled plus commands +PASS: gdb.base/pending.exp: Set pending breakpoint 2 +PASS: gdb.base/pending.exp: multiple pending breakpoints +PASS: gdb.base/pending.exp: Set pending breakpoint 3 +PASS: gdb.base/pending.exp: set ignore count on pending breakpoint 3 +PASS: gdb.base/pending.exp: multiple pending breakpoints 2 +PASS: gdb.base/pending.exp: running to main +PASS: gdb.base/pending.exp: re-enabling pending breakpoint that can resolve instantly +FAIL: gdb.base/pending.exp: continue to resolved breakpoint 2 (the program exited) +FAIL: gdb.base/pending.exp: continue to resolved breakpoint 1 (the program is no longer running) +PASS: gdb.base/pending.exp: Disable other breakpoints +PASS: gdb.base/pending.exp: Disable other breakpoints +FAIL: gdb.base/pending.exp: continue to resolved breakpoint 3 (the program is no longer running) +PASS: gdb.base/pending.exp: set imaginary pending breakpoint +PASS: gdb.base/pending.exp: rerun to main +PASS: gdb.base/pending.exp: verify pending breakpoint after restart +Running ./gdb.base/permissions.exp ... +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: enable observer mode +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: disable observer mode +PASS: gdb.base/permissions.exp: set non-stop off +PASS: gdb.base/permissions.exp: set a global +PASS: gdb.base/permissions.exp: print x +PASS: gdb.base/permissions.exp: set may-write-memory off +PASS: gdb.base/permissions.exp: try to set a global +PASS: gdb.base/permissions.exp: print x +Running ./gdb.base/pie-execl.exp ... +Running ./gdb.base/pointers.exp ... +FAIL: gdb.base/pointers.exp: continuing after dummy() +PASS: gdb.base/pointers.exp: set pointer to beginning of array +PASS: gdb.base/pointers.exp: set pointer to end of array +FAIL: gdb.base/pointers.exp: print object pointed to +FAIL: gdb.base/pointers.exp: print object pointed to #2 +PASS: gdb.base/pointers.exp: pointer1==pointer2 +PASS: gdb.base/pointers.exp: pointer1!=pointer2 +PASS: gdb.base/pointers.exp: pointer1<=pointer2 +PASS: gdb.base/pointers.exp: pointer1>=pointer2 +PASS: gdb.base/pointers.exp: pointer1<pointer2 +PASS: gdb.base/pointers.exp: pointer1>pointer2 +PASS: gdb.base/pointers.exp: set y = *v_int_pointer++ +FAIL: gdb.base/pointers.exp: pointer assignment +FAIL: gdb.base/pointers.exp: and post-increment +PASS: gdb.base/pointers.exp: set y = *--v_int_pointer2 +FAIL: gdb.base/pointers.exp: pointer assignment +FAIL: gdb.base/pointers.exp: and pre-decrement +PASS: gdb.base/pointers.exp: set y =v_int_pointer-v_int_pointer2 +PASS: gdb.base/pointers.exp: pointer1-pointer2 +PASS: gdb.base/pointers.exp: set v_int_pointer=v_int_array +FAIL: gdb.base/pointers.exp: print array element through pointer +FAIL: gdb.base/pointers.exp: print array element through pointer #2 +PASS: gdb.base/pointers.exp: print array element through pointer #3 +PASS: gdb.base/pointers.exp: print array element through pointer #4 +PASS: gdb.base/pointers.exp: print array element through pointer #5 +PASS: gdb.base/pointers.exp: increment rptr +PASS: gdb.base/pointers.exp: print array element through pointer #6 +PASS: gdb.base/pointers.exp: print array element through pointer #7 +PASS: gdb.base/pointers.exp: print array element through pointer #8 +PASS: gdb.base/pointers.exp: print array element w/ pointer arithmetic +FAIL: gdb.base/pointers.exp: print through ptr to ptr +PASS: gdb.base/pointers.exp: continue +PASS: gdb.base/pointers.exp: up from marker1 +PASS: gdb.base/pointers.exp: print value of *pUC +PASS: gdb.base/pointers.exp: ptype pUC +PASS: gdb.base/pointers.exp: print value of *pS +PASS: gdb.base/pointers.exp: ptype pS +PASS: gdb.base/pointers.exp: print value of *pUS +PASS: gdb.base/pointers.exp: ptype pUS +PASS: gdb.base/pointers.exp: print value of *pI +PASS: gdb.base/pointers.exp: ptype pI +PASS: gdb.base/pointers.exp: print value of *pUI +PASS: gdb.base/pointers.exp: ptype pUI +PASS: gdb.base/pointers.exp: print value of *pL +PASS: gdb.base/pointers.exp: ptype pL +PASS: gdb.base/pointers.exp: print value of *pUL +PASS: gdb.base/pointers.exp: ptype pUL +PASS: gdb.base/pointers.exp: print value of *pF +PASS: gdb.base/pointers.exp: ptype pF +PASS: gdb.base/pointers.exp: print value of *pD +PASS: gdb.base/pointers.exp: ptype pD +PASS: gdb.base/pointers.exp: print value of ******ppppppC +PASS: gdb.base/pointers.exp: ptype pC +PASS: gdb.base/pointers.exp: ptype ppC +PASS: gdb.base/pointers.exp: ptype pppC +PASS: gdb.base/pointers.exp: ptype ppppC +PASS: gdb.base/pointers.exp: ptype pppppC +PASS: gdb.base/pointers.exp: ptype ppppppC +PASS: gdb.base/pointers.exp: p instance.array_variable + 0 +Running ./gdb.base/pr10179.exp ... +PASS: gdb.base/pr10179.exp: rbreak foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c:foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c : .* +Running ./gdb.base/pr11022.exp ... +Running ./gdb.base/prelink.exp ... +Running ./gdb.base/printcmds.exp ... +PASS: gdb.base/printcmds.exp: print $pc +PASS: gdb.base/printcmds.exp: print "abc" +PASS: gdb.base/printcmds.exp: print sizeof ("abc") +PASS: gdb.base/printcmds.exp: ptype "abc" +PASS: gdb.base/printcmds.exp: print $cvar = "abc" +PASS: gdb.base/printcmds.exp: print sizeof ($cvar) +PASS: gdb.base/printcmds.exp: print $pc (with file) +PASS: gdb.base/printcmds.exp: set print sevenbit-strings +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set width 0 +PASS: gdb.base/printcmds.exp: p ctable1[120] #1 +PASS: gdb.base/printcmds.exp: p 123 +PASS: gdb.base/printcmds.exp: p -123 +PASS: gdb.base/printcmds.exp: p/d 123 +PASS: gdb.base/printcmds.exp: p 0123 +PASS: gdb.base/printcmds.exp: p 00123 +PASS: gdb.base/printcmds.exp: p -0123 +PASS: gdb.base/printcmds.exp: p/o 0123 +PASS: gdb.base/printcmds.exp: p 0x123 +PASS: gdb.base/printcmds.exp: p -0x123 +PASS: gdb.base/printcmds.exp: p 0x0123 +PASS: gdb.base/printcmds.exp: p -0x0123 +PASS: gdb.base/printcmds.exp: p 0xABCDEF +PASS: gdb.base/printcmds.exp: p 0xabcdef +PASS: gdb.base/printcmds.exp: p 0xAbCdEf +PASS: gdb.base/printcmds.exp: p/x 0x123 +PASS: gdb.base/printcmds.exp: p 0b0 +PASS: gdb.base/printcmds.exp: p 0b1111 +PASS: gdb.base/printcmds.exp: p 0B1111 +PASS: gdb.base/printcmds.exp: p -0b1111 +PASS: gdb.base/printcmds.exp: reject p 0x +PASS: gdb.base/printcmds.exp: reject p 0b +PASS: gdb.base/printcmds.exp: p '' +PASS: gdb.base/printcmds.exp: p ''' +PASS: gdb.base/printcmds.exp: reject p '\' +PASS: gdb.base/printcmds.exp: reject p '\\\' +PASS: gdb.base/printcmds.exp: reject p DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 09 +PASS: gdb.base/printcmds.exp: reject p 079 +PASS: gdb.base/printcmds.exp: reject p 0xG +PASS: gdb.base/printcmds.exp: reject p 0xAG +PASS: gdb.base/printcmds.exp: reject p 0b2 +PASS: gdb.base/printcmds.exp: reject p 0b12 +PASS: gdb.base/printcmds.exp: check for floating addition +PASS: gdb.base/printcmds.exp: p 1. +PASS: gdb.base/printcmds.exp: p 1.5 +PASS: gdb.base/printcmds.exp: p 1.f +PASS: gdb.base/printcmds.exp: p 1.5f +PASS: gdb.base/printcmds.exp: p 1.l +PASS: gdb.base/printcmds.exp: p 1.5l +PASS: gdb.base/printcmds.exp: p 0x1.1 +PASS: gdb.base/printcmds.exp: reject p 123DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 123foobar.bazfoo3 +PASS: gdb.base/printcmds.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.base/printcmds.exp: reject p 1.1x +PASS: gdb.base/printcmds.exp: reject p 1.1ff +PASS: gdb.base/printcmds.exp: reject p 1.1ll +PASS: gdb.base/printcmds.exp: p 'a' +PASS: gdb.base/printcmds.exp: p/c 'a' +PASS: gdb.base/printcmds.exp: p/x 'a' +PASS: gdb.base/printcmds.exp: p/d 'a' +PASS: gdb.base/printcmds.exp: p/t 'a' +PASS: gdb.base/printcmds.exp: p '\141' +PASS: gdb.base/printcmds.exp: p/x '\377' +PASS: gdb.base/printcmds.exp: p '\'' +PASS: gdb.base/printcmds.exp: p '\\' +PASS: gdb.base/printcmds.exp: p ctable1[0] +PASS: gdb.base/printcmds.exp: p ctable1[1] +PASS: gdb.base/printcmds.exp: p ctable1[2] +PASS: gdb.base/printcmds.exp: p ctable1[3] +PASS: gdb.base/printcmds.exp: p ctable1[4] +PASS: gdb.base/printcmds.exp: p ctable1[5] +PASS: gdb.base/printcmds.exp: p ctable1[6] +PASS: gdb.base/printcmds.exp: p ctable1[7] +PASS: gdb.base/printcmds.exp: p ctable1[8] +PASS: gdb.base/printcmds.exp: p ctable1[9] +PASS: gdb.base/printcmds.exp: p ctable1[10] +PASS: gdb.base/printcmds.exp: p ctable1[11] +PASS: gdb.base/printcmds.exp: p ctable1[12] +PASS: gdb.base/printcmds.exp: p ctable1[13] +PASS: gdb.base/printcmds.exp: p ctable1[14] +PASS: gdb.base/printcmds.exp: p ctable1[15] +PASS: gdb.base/printcmds.exp: p ctable1[16] +PASS: gdb.base/printcmds.exp: p ctable1[17] +PASS: gdb.base/printcmds.exp: p ctable1[18] +PASS: gdb.base/printcmds.exp: p ctable1[19] +PASS: gdb.base/printcmds.exp: p ctable1[20] +PASS: gdb.base/printcmds.exp: p ctable1[21] +PASS: gdb.base/printcmds.exp: p ctable1[22] +PASS: gdb.base/printcmds.exp: p ctable1[23] +PASS: gdb.base/printcmds.exp: p ctable1[24] +PASS: gdb.base/printcmds.exp: p ctable1[25] +PASS: gdb.base/printcmds.exp: p ctable1[26] +PASS: gdb.base/printcmds.exp: p ctable1[27] +PASS: gdb.base/printcmds.exp: p ctable1[28] +PASS: gdb.base/printcmds.exp: p ctable1[29] +PASS: gdb.base/printcmds.exp: p ctable1[30] +PASS: gdb.base/printcmds.exp: p ctable1[31] +PASS: gdb.base/printcmds.exp: p ctable1[32] +PASS: gdb.base/printcmds.exp: p ctable1[33] +PASS: gdb.base/printcmds.exp: p ctable1[34] +PASS: gdb.base/printcmds.exp: p ctable1[35] +PASS: gdb.base/printcmds.exp: p ctable1[36] +PASS: gdb.base/printcmds.exp: p ctable1[37] +PASS: gdb.base/printcmds.exp: p ctable1[38] +PASS: gdb.base/printcmds.exp: p ctable1[39] +PASS: gdb.base/printcmds.exp: p ctable1[40] +PASS: gdb.base/printcmds.exp: p ctable1[41] +PASS: gdb.base/printcmds.exp: p ctable1[42] +PASS: gdb.base/printcmds.exp: p ctable1[43] +PASS: gdb.base/printcmds.exp: p ctable1[44] +PASS: gdb.base/printcmds.exp: p ctable1[45] +PASS: gdb.base/printcmds.exp: p ctable1[46] +PASS: gdb.base/printcmds.exp: p ctable1[47] +PASS: gdb.base/printcmds.exp: p ctable1[48] +PASS: gdb.base/printcmds.exp: p ctable1[49] +PASS: gdb.base/printcmds.exp: p ctable1[50] +PASS: gdb.base/printcmds.exp: p ctable1[51] +PASS: gdb.base/printcmds.exp: p ctable1[52] +PASS: gdb.base/printcmds.exp: p ctable1[53] +PASS: gdb.base/printcmds.exp: p ctable1[54] +PASS: gdb.base/printcmds.exp: p ctable1[55] +PASS: gdb.base/printcmds.exp: p ctable1[56] +PASS: gdb.base/printcmds.exp: p ctable1[57] +PASS: gdb.base/printcmds.exp: p ctable1[58] +PASS: gdb.base/printcmds.exp: p ctable1[59] +PASS: gdb.base/printcmds.exp: p ctable1[60] +PASS: gdb.base/printcmds.exp: p ctable1[61] +PASS: gdb.base/printcmds.exp: p ctable1[62] +PASS: gdb.base/printcmds.exp: p ctable1[63] +PASS: gdb.base/printcmds.exp: p ctable1[64] +PASS: gdb.base/printcmds.exp: p ctable1[65] +PASS: gdb.base/printcmds.exp: p ctable1[66] +PASS: gdb.base/printcmds.exp: p ctable1[67] +PASS: gdb.base/printcmds.exp: p ctable1[68] +PASS: gdb.base/printcmds.exp: p ctable1[69] +PASS: gdb.base/printcmds.exp: p ctable1[70] +PASS: gdb.base/printcmds.exp: p ctable1[71] +PASS: gdb.base/printcmds.exp: p ctable1[72] +PASS: gdb.base/printcmds.exp: p ctable1[73] +PASS: gdb.base/printcmds.exp: p ctable1[74] +PASS: gdb.base/printcmds.exp: p ctable1[75] +PASS: gdb.base/printcmds.exp: p ctable1[76] +PASS: gdb.base/printcmds.exp: p ctable1[77] +PASS: gdb.base/printcmds.exp: p ctable1[78] +PASS: gdb.base/printcmds.exp: p ctable1[79] +PASS: gdb.base/printcmds.exp: p ctable1[80] +PASS: gdb.base/printcmds.exp: p ctable1[81] +PASS: gdb.base/printcmds.exp: p ctable1[82] +PASS: gdb.base/printcmds.exp: p ctable1[83] +PASS: gdb.base/printcmds.exp: p ctable1[84] +PASS: gdb.base/printcmds.exp: p ctable1[85] +PASS: gdb.base/printcmds.exp: p ctable1[86] +PASS: gdb.base/printcmds.exp: p ctable1[87] +PASS: gdb.base/printcmds.exp: p ctable1[88] +PASS: gdb.base/printcmds.exp: p ctable1[89] +PASS: gdb.base/printcmds.exp: p ctable1[90] +PASS: gdb.base/printcmds.exp: p ctable1[91] +PASS: gdb.base/printcmds.exp: p ctable1[92] +PASS: gdb.base/printcmds.exp: p ctable1[93] +PASS: gdb.base/printcmds.exp: p ctable1[94] +PASS: gdb.base/printcmds.exp: p ctable1[95] +PASS: gdb.base/printcmds.exp: p ctable1[96] +PASS: gdb.base/printcmds.exp: p ctable1[97] +PASS: gdb.base/printcmds.exp: p ctable1[98] +PASS: gdb.base/printcmds.exp: p ctable1[99] +PASS: gdb.base/printcmds.exp: p ctable1[100] +PASS: gdb.base/printcmds.exp: p ctable1[101] +PASS: gdb.base/printcmds.exp: p ctable1[102] +PASS: gdb.base/printcmds.exp: p ctable1[103] +PASS: gdb.base/printcmds.exp: p ctable1[104] +PASS: gdb.base/printcmds.exp: p ctable1[105] +PASS: gdb.base/printcmds.exp: p ctable1[106] +PASS: gdb.base/printcmds.exp: p ctable1[107] +PASS: gdb.base/printcmds.exp: p ctable1[108] +PASS: gdb.base/printcmds.exp: p ctable1[109] +PASS: gdb.base/printcmds.exp: p ctable1[110] +PASS: gdb.base/printcmds.exp: p ctable1[111] +PASS: gdb.base/printcmds.exp: p ctable1[112] +PASS: gdb.base/printcmds.exp: p ctable1[113] +PASS: gdb.base/printcmds.exp: p ctable1[114] +PASS: gdb.base/printcmds.exp: p ctable1[115] +PASS: gdb.base/printcmds.exp: p ctable1[116] +PASS: gdb.base/printcmds.exp: p ctable1[117] +PASS: gdb.base/printcmds.exp: p ctable1[118] +PASS: gdb.base/printcmds.exp: p ctable1[119] +PASS: gdb.base/printcmds.exp: p ctable1[120] +PASS: gdb.base/printcmds.exp: p ctable1[121] +PASS: gdb.base/printcmds.exp: p ctable1[122] +PASS: gdb.base/printcmds.exp: p ctable1[123] +PASS: gdb.base/printcmds.exp: p ctable1[124] +PASS: gdb.base/printcmds.exp: p ctable1[125] +PASS: gdb.base/printcmds.exp: p ctable1[126] +PASS: gdb.base/printcmds.exp: p ctable1[127] +PASS: gdb.base/printcmds.exp: p ctable1[128] +PASS: gdb.base/printcmds.exp: p ctable1[129] +PASS: gdb.base/printcmds.exp: p ctable1[130] +PASS: gdb.base/printcmds.exp: p ctable1[131] +PASS: gdb.base/printcmds.exp: p ctable1[132] +PASS: gdb.base/printcmds.exp: p ctable1[133] +PASS: gdb.base/printcmds.exp: p ctable1[134] +PASS: gdb.base/printcmds.exp: p ctable1[135] +PASS: gdb.base/printcmds.exp: p ctable1[136] +PASS: gdb.base/printcmds.exp: p ctable1[137] +PASS: gdb.base/printcmds.exp: p ctable1[138] +PASS: gdb.base/printcmds.exp: p ctable1[139] +PASS: gdb.base/printcmds.exp: p ctable1[140] +PASS: gdb.base/printcmds.exp: p ctable1[141] +PASS: gdb.base/printcmds.exp: p ctable1[142] +PASS: gdb.base/printcmds.exp: p ctable1[143] +PASS: gdb.base/printcmds.exp: p ctable1[144] +PASS: gdb.base/printcmds.exp: p ctable1[145] +PASS: gdb.base/printcmds.exp: p ctable1[146] +PASS: gdb.base/printcmds.exp: p ctable1[147] +PASS: gdb.base/printcmds.exp: p ctable1[148] +PASS: gdb.base/printcmds.exp: p ctable1[149] +PASS: gdb.base/printcmds.exp: p ctable1[150] +PASS: gdb.base/printcmds.exp: p ctable1[151] +PASS: gdb.base/printcmds.exp: p ctable1[152] +PASS: gdb.base/printcmds.exp: p ctable1[153] +PASS: gdb.base/printcmds.exp: p ctable1[154] +PASS: gdb.base/printcmds.exp: p ctable1[155] +PASS: gdb.base/printcmds.exp: p ctable1[156] +PASS: gdb.base/printcmds.exp: p ctable1[157] +PASS: gdb.base/printcmds.exp: p ctable1[158] +PASS: gdb.base/printcmds.exp: p ctable1[159] +PASS: gdb.base/printcmds.exp: p ctable1[160] +PASS: gdb.base/printcmds.exp: p ctable1[161] +PASS: gdb.base/printcmds.exp: p ctable1[162] +PASS: gdb.base/printcmds.exp: p ctable1[163] +PASS: gdb.base/printcmds.exp: p ctable1[164] +PASS: gdb.base/printcmds.exp: p ctable1[165] +PASS: gdb.base/printcmds.exp: p ctable1[166] +PASS: gdb.base/printcmds.exp: p ctable1[167] +PASS: gdb.base/printcmds.exp: p ctable1[168] +PASS: gdb.base/printcmds.exp: p ctable1[169] +PASS: gdb.base/printcmds.exp: p ctable1[170] +PASS: gdb.base/printcmds.exp: p ctable1[171] +PASS: gdb.base/printcmds.exp: p ctable1[172] +PASS: gdb.base/printcmds.exp: p ctable1[173] +PASS: gdb.base/printcmds.exp: p ctable1[174] +PASS: gdb.base/printcmds.exp: p ctable1[175] +PASS: gdb.base/printcmds.exp: p ctable1[176] +PASS: gdb.base/printcmds.exp: p ctable1[177] +PASS: gdb.base/printcmds.exp: p ctable1[178] +PASS: gdb.base/printcmds.exp: p ctable1[179] +PASS: gdb.base/printcmds.exp: p ctable1[180] +PASS: gdb.base/printcmds.exp: p ctable1[181] +PASS: gdb.base/printcmds.exp: p ctable1[182] +PASS: gdb.base/printcmds.exp: p ctable1[183] +PASS: gdb.base/printcmds.exp: p ctable1[184] +PASS: gdb.base/printcmds.exp: p ctable1[185] +PASS: gdb.base/printcmds.exp: p ctable1[186] +PASS: gdb.base/printcmds.exp: p ctable1[187] +PASS: gdb.base/printcmds.exp: p ctable1[188] +PASS: gdb.base/printcmds.exp: p ctable1[189] +PASS: gdb.base/printcmds.exp: p ctable1[190] +PASS: gdb.base/printcmds.exp: p ctable1[191] +PASS: gdb.base/printcmds.exp: p ctable1[192] +PASS: gdb.base/printcmds.exp: p ctable1[193] +PASS: gdb.base/printcmds.exp: p ctable1[194] +PASS: gdb.base/printcmds.exp: p ctable1[195] +PASS: gdb.base/printcmds.exp: p ctable1[196] +PASS: gdb.base/printcmds.exp: p ctable1[197] +PASS: gdb.base/printcmds.exp: p ctable1[198] +PASS: gdb.base/printcmds.exp: p ctable1[199] +PASS: gdb.base/printcmds.exp: p ctable1[200] +PASS: gdb.base/printcmds.exp: p ctable1[201] +PASS: gdb.base/printcmds.exp: p ctable1[202] +PASS: gdb.base/printcmds.exp: p ctable1[203] +PASS: gdb.base/printcmds.exp: p ctable1[204] +PASS: gdb.base/printcmds.exp: p ctable1[205] +PASS: gdb.base/printcmds.exp: p ctable1[206] +PASS: gdb.base/printcmds.exp: p ctable1[207] +PASS: gdb.base/printcmds.exp: p ctable1[208] +PASS: gdb.base/printcmds.exp: p ctable1[209] +PASS: gdb.base/printcmds.exp: p ctable1[210] +PASS: gdb.base/printcmds.exp: p ctable1[211] +PASS: gdb.base/printcmds.exp: p ctable1[212] +PASS: gdb.base/printcmds.exp: p ctable1[213] +PASS: gdb.base/printcmds.exp: p ctable1[214] +PASS: gdb.base/printcmds.exp: p ctable1[215] +PASS: gdb.base/printcmds.exp: p ctable1[216] +PASS: gdb.base/printcmds.exp: p ctable1[217] +PASS: gdb.base/printcmds.exp: p ctable1[218] +PASS: gdb.base/printcmds.exp: p ctable1[219] +PASS: gdb.base/printcmds.exp: p ctable1[220] +PASS: gdb.base/printcmds.exp: p ctable1[221] +PASS: gdb.base/printcmds.exp: p ctable1[222] +PASS: gdb.base/printcmds.exp: p ctable1[223] +PASS: gdb.base/printcmds.exp: p ctable1[224] +PASS: gdb.base/printcmds.exp: p ctable1[225] +PASS: gdb.base/printcmds.exp: p ctable1[226] +PASS: gdb.base/printcmds.exp: p ctable1[227] +PASS: gdb.base/printcmds.exp: p ctable1[228] +PASS: gdb.base/printcmds.exp: p ctable1[229] +PASS: gdb.base/printcmds.exp: p ctable1[230] +PASS: gdb.base/printcmds.exp: p ctable1[231] +PASS: gdb.base/printcmds.exp: p ctable1[232] +PASS: gdb.base/printcmds.exp: p ctable1[233] +PASS: gdb.base/printcmds.exp: p ctable1[234] +PASS: gdb.base/printcmds.exp: p ctable1[235] +PASS: gdb.base/printcmds.exp: p ctable1[236] +PASS: gdb.base/printcmds.exp: p ctable1[237] +PASS: gdb.base/printcmds.exp: p ctable1[238] +PASS: gdb.base/printcmds.exp: p ctable1[239] +PASS: gdb.base/printcmds.exp: p ctable1[240] +PASS: gdb.base/printcmds.exp: p ctable1[241] +PASS: gdb.base/printcmds.exp: p ctable1[242] +PASS: gdb.base/printcmds.exp: p ctable1[243] +PASS: gdb.base/printcmds.exp: p ctable1[244] +PASS: gdb.base/printcmds.exp: p ctable1[245] +PASS: gdb.base/printcmds.exp: p ctable1[246] +PASS: gdb.base/printcmds.exp: p ctable1[247] +PASS: gdb.base/printcmds.exp: p ctable1[248] +PASS: gdb.base/printcmds.exp: p ctable1[249] +PASS: gdb.base/printcmds.exp: p ctable1[250] +PASS: gdb.base/printcmds.exp: p ctable1[251] +PASS: gdb.base/printcmds.exp: p ctable1[252] +PASS: gdb.base/printcmds.exp: p ctable1[253] +PASS: gdb.base/printcmds.exp: p ctable1[254] +PASS: gdb.base/printcmds.exp: p ctable1[255] +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 2 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: set print elements 3 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: set print elements 4 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 6 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: set print elements 7 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: set print elements 9 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: set print elements 10 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: set print elements 11 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: set print elements 12 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: set print elements 13 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: set print elements 14 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: set print elements 15 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: set print elements 16 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: correct element repeats in array embedded at offset > 0 +PASS: gdb.base/printcmds.exp: set print elements 0 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 0 +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 19 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 19 +PASS: gdb.base/printcmds.exp: set print elements 20 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 20 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable1[0] +PASS: gdb.base/printcmds.exp: p &ctable1[1] +PASS: gdb.base/printcmds.exp: p &ctable1[1*8] +PASS: gdb.base/printcmds.exp: p &ctable1[2*8] +PASS: gdb.base/printcmds.exp: p &ctable1[3*8] +PASS: gdb.base/printcmds.exp: p &ctable1[4*8] +PASS: gdb.base/printcmds.exp: p &ctable1[5*8] +PASS: gdb.base/printcmds.exp: p &ctable1[6*8] +PASS: gdb.base/printcmds.exp: p &ctable1[7*8] +PASS: gdb.base/printcmds.exp: p &ctable1[8*8] +PASS: gdb.base/printcmds.exp: p &ctable1[9*8] +PASS: gdb.base/printcmds.exp: p &ctable1[10*8] +PASS: gdb.base/printcmds.exp: p &ctable1[11*8] +PASS: gdb.base/printcmds.exp: p &ctable1[12*8] +PASS: gdb.base/printcmds.exp: p &ctable1[13*8] +PASS: gdb.base/printcmds.exp: p &ctable1[14*8] +PASS: gdb.base/printcmds.exp: p &ctable1[15*8] +PASS: gdb.base/printcmds.exp: p &ctable1[16*8] +PASS: gdb.base/printcmds.exp: p &ctable1[17*8] +PASS: gdb.base/printcmds.exp: p &ctable1[18*8] +PASS: gdb.base/printcmds.exp: p &ctable1[19*8] +PASS: gdb.base/printcmds.exp: p &ctable1[20*8] +PASS: gdb.base/printcmds.exp: p &ctable1[21*8] +PASS: gdb.base/printcmds.exp: p &ctable1[22*8] +PASS: gdb.base/printcmds.exp: p &ctable1[23*8] +PASS: gdb.base/printcmds.exp: p &ctable1[24*8] +PASS: gdb.base/printcmds.exp: p &ctable1[25*8] +PASS: gdb.base/printcmds.exp: p &ctable1[26*8] +PASS: gdb.base/printcmds.exp: p &ctable1[27*8] +PASS: gdb.base/printcmds.exp: p &ctable1[28*8] +PASS: gdb.base/printcmds.exp: p &ctable1[29*8] +PASS: gdb.base/printcmds.exp: p &ctable1[30*8] +PASS: gdb.base/printcmds.exp: p &ctable1[31*8] +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: p a1[0] +PASS: gdb.base/printcmds.exp: p a1[9] +PASS: gdb.base/printcmds.exp: p a2 +PASS: gdb.base/printcmds.exp: p a2[0] +PASS: gdb.base/printcmds.exp: p a2[3] +PASS: gdb.base/printcmds.exp: set print null-stop on +PASS: gdb.base/printcmds.exp: print a2 with null-stop on +PASS: gdb.base/printcmds.exp: set print null-stop off +PASS: gdb.base/printcmds.exp: p int1dim[0]@2 +PASS: gdb.base/printcmds.exp: p int1dim[0]@2@3 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print address on +PASS: gdb.base/printcmds.exp: p arrays +PASS: gdb.base/printcmds.exp: p parrays +PASS: gdb.base/printcmds.exp: p parrays->array1 +PASS: gdb.base/printcmds.exp: p &parrays->array1 +PASS: gdb.base/printcmds.exp: p parrays->array2 +PASS: gdb.base/printcmds.exp: p &parrays->array2 +PASS: gdb.base/printcmds.exp: p parrays->array3 +PASS: gdb.base/printcmds.exp: p &parrays->array3 +PASS: gdb.base/printcmds.exp: p parrays->array4 +PASS: gdb.base/printcmds.exp: p &parrays->array4 +PASS: gdb.base/printcmds.exp: p parrays->array5 +PASS: gdb.base/printcmds.exp: p &parrays->array5 +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set print elements 50 +PASS: gdb.base/printcmds.exp: p "a string" +PASS: gdb.base/printcmds.exp: p "embedded \000 null" +PASS: gdb.base/printcmds.exp: p "abcd"[2] +PASS: gdb.base/printcmds.exp: p sizeof ("abcdef") +PASS: gdb.base/printcmds.exp: ptype "foo" +FAIL: gdb.base/printcmds.exp: p *"foo" (the program exited) +PASS: gdb.base/printcmds.exp: ptype *"foo" +FAIL: gdb.base/printcmds.exp: p &*"foo" +FAIL: gdb.base/printcmds.exp: ptype &*"foo" +FAIL: gdb.base/printcmds.exp: p (char *)"foo" +PASS: gdb.base/printcmds.exp: print {'a','b','c'} +PASS: gdb.base/printcmds.exp: print {4,5,6}[2] +PASS: gdb.base/printcmds.exp: print *&{4,5,6}[1] +PASS: gdb.base/printcmds.exp: print some_volatile_enum +PASS: gdb.base/printcmds.exp: print three +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%d,z=%d\n", 5, 6, 7 +FAIL: gdb.base/printcmds.exp: printf "string=%.4sxx\n", teststring +FAIL: gdb.base/printcmds.exp: printf "string=%sxx\n", teststring +PASS: gdb.base/printcmds.exp: printf "%f is fun\n", 1.0 +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%f,z=%d\n", 5, 6.0, 7 +PASS: gdb.base/printcmds.exp: printf "%x %f, %c %x, %x, %f\n", 0xbad, -99.541, 'z', 0xfeedface, 0xdeadbeef, 5.0 +PASS: gdb.base/printcmds.exp: printf "%c\n", "x"[1,0] +PASS: gdb.base/printcmds.exp: printf "%%%d%%\n", 5 +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E1df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E-10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E96df +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E1dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E-10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E384dd +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E1dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E-10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E6144dl +PASS: gdb.base/printcmds.exp: printf "%Hf %Hf\n",1.2df,1.3df +PASS: gdb.base/printcmds.exp: set print symbol on +PASS: gdb.base/printcmds.exp: print &three +FAIL: gdb.base/printcmds.exp: print parrays +PASS: gdb.base/printcmds.exp: set print symbol off +PASS: gdb.base/printcmds.exp: print invalid_LLL +PASS: gdb.base/printcmds.exp: print invalid_LLE +PASS: gdb.base/printcmds.exp: print invalid_LLR +PASS: gdb.base/printcmds.exp: print invalid_LLS +PASS: gdb.base/printcmds.exp: print invalid_ELL +PASS: gdb.base/printcmds.exp: print invalid_ELR +PASS: gdb.base/printcmds.exp: print invalid_ELS +PASS: gdb.base/printcmds.exp: print invalid_RLL +PASS: gdb.base/printcmds.exp: print invalid_RLE +PASS: gdb.base/printcmds.exp: print invalid_RLR +PASS: gdb.base/printcmds.exp: print invalid_RLS +PASS: gdb.base/printcmds.exp: print invalid_SLL +PASS: gdb.base/printcmds.exp: print invalid_SLE +PASS: gdb.base/printcmds.exp: print invalid_SLR +PASS: gdb.base/printcmds.exp: print invalid_SLS +PASS: gdb.base/printcmds.exp: print invalid_LRL +PASS: gdb.base/printcmds.exp: print invalid_LRE +PASS: gdb.base/printcmds.exp: print invalid_LRR +PASS: gdb.base/printcmds.exp: print invalid_LRS +PASS: gdb.base/printcmds.exp: print invalid_ERL +PASS: gdb.base/printcmds.exp: print invalid_ERR +PASS: gdb.base/printcmds.exp: print invalid_ERS +PASS: gdb.base/printcmds.exp: print invalid_RRL +PASS: gdb.base/printcmds.exp: print invalid_RRE +PASS: gdb.base/printcmds.exp: print invalid_RRR +PASS: gdb.base/printcmds.exp: print invalid_RRS +PASS: gdb.base/printcmds.exp: print invalid_SRL +PASS: gdb.base/printcmds.exp: print invalid_SRE +PASS: gdb.base/printcmds.exp: print invalid_SRR +PASS: gdb.base/printcmds.exp: print invalid_SRS +PASS: gdb.base/printcmds.exp: print invalid_LSL +PASS: gdb.base/printcmds.exp: print invalid_LSE +PASS: gdb.base/printcmds.exp: print invalid_LSR +PASS: gdb.base/printcmds.exp: print invalid_LSS +PASS: gdb.base/printcmds.exp: print invalid_ESL +PASS: gdb.base/printcmds.exp: print invalid_ESR +PASS: gdb.base/printcmds.exp: print invalid_ESS +PASS: gdb.base/printcmds.exp: print invalid_RSL +PASS: gdb.base/printcmds.exp: print invalid_RSE +PASS: gdb.base/printcmds.exp: print invalid_RSR +PASS: gdb.base/printcmds.exp: print invalid_RSS +PASS: gdb.base/printcmds.exp: print invalid_SSL +PASS: gdb.base/printcmds.exp: print invalid_SSE +PASS: gdb.base/printcmds.exp: print invalid_SSR +PASS: gdb.base/printcmds.exp: print invalid_SSS +Running ./gdb.base/print-file-var.exp ... +PASS: gdb.base/print-file-var.exp: breapoint past v1 & v2 initialization +PASS: gdb.base/print-file-var.exp: continue to STOP marker +FAIL: gdb.base/print-file-var.exp: print 'print-file-var-lib1.c'::this_version_id == v1 +FAIL: gdb.base/print-file-var.exp: print 'print-file-var-lib2.c'::this_version_id == v2 +Running ./gdb.base/prologue.exp ... +PASS: gdb.base/prologue.exp: setting breakpoint at marker +PASS: gdb.base/prologue.exp: continue to marker +PASS: gdb.base/prologue.exp: reading $pc: marker +PASS: gdb.base/prologue.exp: setting breakpoint at other +PASS: gdb.base/prologue.exp: continue to other +PASS: gdb.base/prologue.exp: reading $pc: other +PASS: gdb.base/prologue.exp: same pc from minimal symbol +Running ./gdb.base/prologue-include.exp ... +PASS: gdb.base/prologue-include.exp: breakpoint main +Running ./gdb.base/psymtab.exp ... +PASS: gdb.base/psymtab.exp: psymtab pending setup +PASS: gdb.base/psymtab.exp: Don't search past end of psymtab. +Running ./gdb.base/ptr-typedef.exp ... +PASS: gdb.base/ptr-typedef.exp: print foo_ptr +PASS: gdb.base/ptr-typedef.exp: print foz_ptr +Running ./gdb.base/ptype.exp ... +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member +PASS: gdb.base/ptype.exp: ptype structure +PASS: gdb.base/ptype.exp: ptype v_struct1.v_float_member +PASS: gdb.base/ptype.exp: ptype v_struct1->v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p.v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p->v_float_member +PASS: gdb.base/ptype.exp: ptype linked list structure +PASS: gdb.base/ptype.exp: ptype union +PASS: gdb.base/ptype.exp: ptype linked list union +PASS: gdb.base/ptype.exp: ptype unnamed enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration +PASS: gdb.base/ptype.exp: ptype unnamed typedef'd enumeration +PASS: gdb.base/ptype.exp: list main +PASS: gdb.base/ptype.exp: whatis unnamed typedef'd enum (compiler bug in IBM's xlc) +PASS: gdb.base/ptype.exp: printing typedef'd struct +PASS: gdb.base/ptype.exp: printing typedef'd union +PASS: gdb.base/ptype.exp: ptype named typedef'd enumf'd enum +PASS: gdb.base/ptype.exp: ptype misordered enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration member +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member #2 +PASS: gdb.base/ptype.exp: ptype short +PASS: gdb.base/ptype.exp: ptype int +PASS: gdb.base/ptype.exp: ptype t_char_array +PASS: gdb.base/ptype.exp: ptype pv_char_array +PASS: gdb.base/ptype.exp: ptype outer structure +PASS: gdb.base/ptype.exp: ptype inner structure +PASS: gdb.base/ptype.exp: ptype inner union +PASS: gdb.base/ptype.exp: ptype nested structure +PASS: gdb.base/ptype.exp: ptype outer int +PASS: gdb.base/ptype.exp: ptype nested structure #2 +PASS: gdb.base/ptype.exp: ptype inner int +PASS: gdb.base/ptype.exp: ptype nested union +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype func_type +PASS: gdb.base/ptype.exp: ptype old_fptr +PASS: gdb.base/ptype.exp: ptype new_fptr +PASS: gdb.base/ptype.exp: ptype fptr +PASS: gdb.base/ptype.exp: ptype fptr2 +PASS: gdb.base/ptype.exp: ptype xptr +PASS: gdb.base/ptype.exp: ptype ffptr +PASS: gdb.base/ptype.exp: ptype fffptr +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of charfoo +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of charfoo +PASS: gdb.base/ptype.exp: ptype "abc" +PASS: gdb.base/ptype.exp: ptype {'a','b','c'} +PASS: gdb.base/ptype.exp: ptype {0,1,2} +PASS: gdb.base/ptype.exp: ptype {(long)0,(long)1,(long)2} +PASS: gdb.base/ptype.exp: ptype {(float)0,(float)1,(float)2} +PASS: gdb.base/ptype.exp: ptype {{0,1,2},{3,4,5}} +PASS: gdb.base/ptype.exp: ptype {4,5,6}[2] +PASS: gdb.base/ptype.exp: ptype *&{4,5,6}[1] +PASS: gdb.base/ptype.exp: ptype $pc +Running ./gdb.base/radix.exp ... +PASS: gdb.base/radix.exp: initialize radix, input radix 2 +PASS: gdb.base/radix.exp: set input-radix 2 +PASS: gdb.base/radix.exp: show radix, input radix 2 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 2 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 2 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 2 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 2 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 2 +PASS: gdb.base/radix.exp: print 10; expect 2; input radix 2 +PASS: gdb.base/radix.exp: print 11; expect 3; input radix 2 +PASS: gdb.base/radix.exp: print -10; expect -2; input radix 2 +PASS: gdb.base/radix.exp: print -11; expect -3; input radix 2 +PASS: gdb.base/radix.exp: print 100; expect 4; input radix 2 +PASS: gdb.base/radix.exp: print 101; expect 5; input radix 2 +PASS: gdb.base/radix.exp: print -100; expect -4; input radix 2 +PASS: gdb.base/radix.exp: print -101; expect -5; input radix 2 +PASS: gdb.base/radix.exp: print 10101; expect 21; input radix 2 +PASS: gdb.base/radix.exp: print 4; expect Invalid number "4"\.; input radix 2 +PASS: gdb.base/radix.exp: print -2; expect Invalid number "2"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 3 +PASS: gdb.base/radix.exp: set input-radix 3 +PASS: gdb.base/radix.exp: show radix, input radix 3 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 3 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 3 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 3 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 3 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 3 +PASS: gdb.base/radix.exp: print 10; expect 3; input radix 3 +PASS: gdb.base/radix.exp: print 11; expect 4; input radix 3 +PASS: gdb.base/radix.exp: print -10; expect -3; input radix 3 +PASS: gdb.base/radix.exp: print -11; expect -4; input radix 3 +PASS: gdb.base/radix.exp: print 100; expect 9; input radix 3 +PASS: gdb.base/radix.exp: print 101; expect 10; input radix 3 +PASS: gdb.base/radix.exp: print -100; expect -9; input radix 3 +PASS: gdb.base/radix.exp: print -101; expect -10; input radix 3 +PASS: gdb.base/radix.exp: print 10101; expect 91; input radix 3 +PASS: gdb.base/radix.exp: print 2; expect 2; input radix 3 +PASS: gdb.base/radix.exp: print 20; expect 6; input radix 3 +PASS: gdb.base/radix.exp: print 3; expect Invalid number "3"\.; input radix 3 +PASS: gdb.base/radix.exp: print 30; expect Invalid number "30"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 8 +PASS: gdb.base/radix.exp: set input-radix 8 +PASS: gdb.base/radix.exp: show radix, input radix 8 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 8 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 8 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 8 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 8 +PASS: gdb.base/radix.exp: print 10; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 11; expect 9; input radix 8 +PASS: gdb.base/radix.exp: print -10; expect -8; input radix 8 +PASS: gdb.base/radix.exp: print -11; expect -9; input radix 8 +PASS: gdb.base/radix.exp: print 100; expect 64; input radix 8 +PASS: gdb.base/radix.exp: print 101; expect 65; input radix 8 +PASS: gdb.base/radix.exp: print -100; expect -64; input radix 8 +PASS: gdb.base/radix.exp: print -101; expect -65; input radix 8 +PASS: gdb.base/radix.exp: print 10101; expect 4161; input radix 8 +PASS: gdb.base/radix.exp: print 20; expect 16; input radix 8 +PASS: gdb.base/radix.exp: print -20; expect -16; input radix 8 +PASS: gdb.base/radix.exp: print 8; expect Invalid number "8".; input radix 8 +PASS: gdb.base/radix.exp: print -9; expect Invalid number "9".; input radix 8 +PASS: gdb.base/radix.exp: initialize radix, input radix 10 +PASS: gdb.base/radix.exp: set input-radix 10 +PASS: gdb.base/radix.exp: show radix, input radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 10 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 10 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 10 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; input radix 10 +PASS: gdb.base/radix.exp: print 11; expect 11; input radix 10 +PASS: gdb.base/radix.exp: print -10; expect -10; input radix 10 +PASS: gdb.base/radix.exp: print -11; expect -11; input radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; input radix 10 +PASS: gdb.base/radix.exp: print 101; expect 101; input radix 10 +PASS: gdb.base/radix.exp: print -100; expect -100; input radix 10 +PASS: gdb.base/radix.exp: print -101; expect -101; input radix 10 +PASS: gdb.base/radix.exp: print 10101; expect 10101; input radix 10 +PASS: gdb.base/radix.exp: print -12; expect -12; input radix 10 +PASS: gdb.base/radix.exp: initialize radix, input radix 16 +PASS: gdb.base/radix.exp: set input-radix 16 +PASS: gdb.base/radix.exp: show radix, input radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 16 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 16 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 16 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 16 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 16 +PASS: gdb.base/radix.exp: print 10; expect 16; input radix 16 +PASS: gdb.base/radix.exp: print 11; expect 17; input radix 16 +PASS: gdb.base/radix.exp: print -10; expect -16; input radix 16 +PASS: gdb.base/radix.exp: print -11; expect -17; input radix 16 +PASS: gdb.base/radix.exp: print 100; expect 256; input radix 16 +PASS: gdb.base/radix.exp: print 101; expect 257; input radix 16 +PASS: gdb.base/radix.exp: print -100; expect -256; input radix 16 +PASS: gdb.base/radix.exp: print -101; expect -257; input radix 16 +PASS: gdb.base/radix.exp: print 10101; expect 65793; input radix 16 +PASS: gdb.base/radix.exp: initialize radix, output radix 8 +PASS: gdb.base/radix.exp: set output-radix 8 +PASS: gdb.base/radix.exp: show radix, output radix 8 +PASS: gdb.base/radix.exp: print 010; expect 010; output radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 17; output radix 8 +PASS: gdb.base/radix.exp: print 10; expect 12; output radix 8 +PASS: gdb.base/radix.exp: print 100; expect 144; output radix 8 +KFAIL: gdb.base/radix.exp: print 20.; expect 24; output radix 8 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 24; output radix 8 +PASS: gdb.base/radix.exp: initialize radix, output radix 10 +PASS: gdb.base/radix.exp: set output-radix 10 +PASS: gdb.base/radix.exp: show radix, output radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; output radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; output radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; output radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: initialize radix, output radix 16 +PASS: gdb.base/radix.exp: set output-radix 16 +PASS: gdb.base/radix.exp: show radix, output radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect f; output radix 16 +PASS: gdb.base/radix.exp: print 10; expect a; output radix 16 +PASS: gdb.base/radix.exp: print 100; expect 64; output radix 16 +KFAIL: gdb.base/radix.exp: print 20.; expect 14; output radix 16 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 14; output radix 16 +PASS: gdb.base/radix.exp: Reset radices +PASS: gdb.base/radix.exp: Reject input-radix 0 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject input-radix 1 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: Reject output-radix 0 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject output-radix 1 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: set radix 7 rejected +PASS: gdb.base/radix.exp: Output radix unchanged after rejection through set radix command +Running ./gdb.base/randomize.exp ... +UNTESTED: gdb.base/randomize.exp: Disabling randomization is not supported on this Linux GDB +Running ./gdb.base/random-signal.exp ... +PASS: gdb.base/random-signal.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/random-signal.exp: watch v +PASS: gdb.base/random-signal.exp: continue +FAIL: gdb.base/random-signal.exp: stop with control-c +Running ./gdb.base/readline-ask.exp ... +PASS: gdb.base/readline-ask.exp: set width 50 +PASS: gdb.base/readline-ask.exp: set height 3 +PASS: gdb.base/readline-ask.exp: bell for more message +FAIL: gdb.base/readline-ask.exp: more message for 01 and 02 +FAIL: gdb.base/readline-ask.exp: more message for 03 +FAIL: gdb.base/readline-ask.exp: more finish for 04 +ERROR: Undefined command "foo". +UNRESOLVED: gdb.base/readline-ask.exp: abort more message +PASS: gdb.base/readline-ask.exp: bell for ask message +FAIL: gdb.base/readline-ask.exp: ask message +Running ./gdb.base/readline.exp ... +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - final prompt +PASS: gdb.base/readline.exp: print 42 +PASS: gdb.base/readline.exp: arrow keys with secondary prompt +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +Running ./gdb.base/realname-expand.exp ... +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: rbreak realname-expand-real.c:func +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: break realname-expand-real.c:func +Running ./gdb.base/recpar.exp ... +PASS: gdb.base/recpar.exp: break recpar.c:26 if n == 3 +PASS: gdb.base/recpar.exp: continue +PASS: gdb.base/recpar.exp: backtrace +PASS: gdb.base/recpar.exp: frame 2 +PASS: gdb.base/recpar.exp: print foo::val +Running ./gdb.base/recurse.exp ... +PASS: gdb.base/recurse.exp: next over b = 0 in first instance +PASS: gdb.base/recurse.exp: set first instance watchpoint +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 9) +PASS: gdb.base/recurse.exp: continue to recurse (a = 8) +PASS: gdb.base/recurse.exp: continue to recurse (a = 7) +PASS: gdb.base/recurse.exp: continue to recurse (a = 6) +PASS: gdb.base/recurse.exp: continue to recurse (a = 5) +PASS: gdb.base/recurse.exp: next over b = 0 in second instance +PASS: gdb.base/recurse.exp: set second instance watchpoint +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 4) +PASS: gdb.base/recurse.exp: continue to recurse (a = 3) +PASS: gdb.base/recurse.exp: continue to recurse (a = 2) +PASS: gdb.base/recurse.exp: continue to recurse (a = 1) +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, second time +PASS: gdb.base/recurse.exp: second instance watchpoint deleted when leaving scope +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, second time +PASS: gdb.base/recurse.exp: first instance watchpoint deleted when leaving scope +Running ./gdb.base/relational.exp ... +PASS: gdb.base/relational.exp: set variable x=14 +PASS: gdb.base/relational.exp: set variable y=2 +PASS: gdb.base/relational.exp: set variable z=2 +PASS: gdb.base/relational.exp: set variable w=3 +PASS: gdb.base/relational.exp: print value of x +PASS: gdb.base/relational.exp: print value of y +PASS: gdb.base/relational.exp: print value of z +PASS: gdb.base/relational.exp: print value of w +PASS: gdb.base/relational.exp: print value of x<y +PASS: gdb.base/relational.exp: print value of x<=y +PASS: gdb.base/relational.exp: print value of x>y +PASS: gdb.base/relational.exp: print value of x>=y +PASS: gdb.base/relational.exp: print value of x==y +PASS: gdb.base/relational.exp: print value of x!=y +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<z +PASS: gdb.base/relational.exp: print value of x<=y<=z +PASS: gdb.base/relational.exp: print value of x>y>z +PASS: gdb.base/relational.exp: print value of x>=y>=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x==y==z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x!=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y==z +PASS: gdb.base/relational.exp: print value of x<y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<=z +PASS: gdb.base/relational.exp: print value of x<y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y>z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y!=z +PASS: gdb.base/relational.exp: set x to 4 +PASS: gdb.base/relational.exp: print value of x>y<=z +PASS: gdb.base/relational.exp: print value of x>=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=y<=z +PASS: gdb.base/relational.exp: print value of x<=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x<=y!=z +PASS: gdb.base/relational.exp: print value of x==y!=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=(y<z) +PASS: gdb.base/relational.exp: print value of x>=(y!=z) +PASS: gdb.base/relational.exp: print value of x==(y==z) +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of (x==y)<z +Running ./gdb.base/relativedebug.exp ... +PASS: gdb.base/relativedebug.exp: continue +FAIL: gdb.base/relativedebug.exp: pause found in backtrace +Running ./gdb.base/relocate.exp ... +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o 0 +PASS: gdb.base/relocate.exp: get address of static_foo +PASS: gdb.base/relocate.exp: get address of static_bar +PASS: gdb.base/relocate.exp: static variables have different addresses +PASS: gdb.base/relocate.exp: get address of global_foo +PASS: gdb.base/relocate.exp: get address of global_bar +PASS: gdb.base/relocate.exp: global variables have different addresses +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: get address of function_bar +PASS: gdb.base/relocate.exp: functions have different addresses +PASS: gdb.base/relocate.exp: set $offset = 0x10000 +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o $offset +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: function foo has a different address +PASS: gdb.base/relocate.exp: print static_foo +PASS: gdb.base/relocate.exp: print static_bar +PASS: gdb.base/relocate.exp: print global_foo +PASS: gdb.base/relocate.exp: print global_bar +Running ./gdb.base/remote.exp ... +PASS: gdb.base/remote.exp: write-packet default +PASS: gdb.base/remote.exp: set write-packet - NULL +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 20 +PASS: gdb.base/remote.exp: set write-packet - small +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 1 +PASS: gdb.base/remote.exp: set write-packet - very-small +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set write size class +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 16385 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 +PASS: gdb.base/remote.exp: get integer valueof "sizeof (random_data)" (49152) +PASS: gdb.base/remote.exp: x/8ub random_data +PASS: gdb.base/remote.exp: x/8ub random_data + 400 - 4 +PASS: gdb.base/remote.exp: x/8ub random_data + 16384 - 4 +PASS: gdb.base/remote.exp: set remote memory-read-packet-size 16 +PASS: gdb.base/remote.exp: show remote memory-read-packet-size +PASS: gdb.base/remote.exp: x/17ub random_data +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit 2147483647 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit 2147483647 +Running ./gdb.base/remotetimeout.exp ... +Running ./gdb.base/reread.exp ... +FAIL: gdb.base/reread.exp: breakpoint foo in first file +FAIL: gdb.base/reread.exp: run to foo() +UNSUPPORTED: gdb.base/reread.exp: run to foo() second time +UNSUPPORTED: gdb.base/reread.exp: second pass: GDB should check for changes before running +Running ./gdb.base/restore.exp ... +PASS: gdb.base/restore.exp: tbreak caller1 +PASS: gdb.base/restore.exp: run to caller1 +PASS: gdb.base/restore.exp: caller1 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: tbreak caller2 +PASS: gdb.base/restore.exp: run to caller2 +PASS: gdb.base/restore.exp: caller2 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: tbreak caller3 +PASS: gdb.base/restore.exp: run to caller3 +PASS: gdb.base/restore.exp: caller3 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: tbreak caller4 +PASS: gdb.base/restore.exp: run to caller4 +PASS: gdb.base/restore.exp: caller4 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: tbreak caller5 +PASS: gdb.base/restore.exp: run to caller5 +PASS: gdb.base/restore.exp: caller5 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l5 to 32496 +Running ./gdb.base/return2.exp ... +PASS: gdb.base/return2.exp: set break on void_func +PASS: gdb.base/return2.exp: continue to void_func +PASS: gdb.base/return2.exp: return from void_func +PASS: gdb.base/return2.exp: void function returned successfully +PASS: gdb.base/return2.exp: set break on char_func +PASS: gdb.base/return2.exp: continue to char_func +PASS: gdb.base/return2.exp: return from char_func +PASS: gdb.base/return2.exp: char value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on short_func +PASS: gdb.base/return2.exp: continue to short_func +PASS: gdb.base/return2.exp: return from short_func +PASS: gdb.base/return2.exp: short value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on int_func +PASS: gdb.base/return2.exp: continue to int_func +PASS: gdb.base/return2.exp: return from int_func +PASS: gdb.base/return2.exp: int value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_func +PASS: gdb.base/return2.exp: continue to long_func +PASS: gdb.base/return2.exp: return from long_func +PASS: gdb.base/return2.exp: long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_long_func +PASS: gdb.base/return2.exp: continue to long_long_func +PASS: gdb.base/return2.exp: return from long_long_func +PASS: gdb.base/return2.exp: long_long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on float_func +PASS: gdb.base/return2.exp: continue to float_func +PASS: gdb.base/return2.exp: return from float_func +PASS: gdb.base/return2.exp: float value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on double_func +PASS: gdb.base/return2.exp: continue to double_func +PASS: gdb.base/return2.exp: return from double_func +FAIL: gdb.base/return2.exp: double value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +Running ./gdb.base/return.exp ... +PASS: gdb.base/return.exp: simple return +PASS: gdb.base/return.exp: break func2 +PASS: gdb.base/return.exp: break func3 +PASS: gdb.base/return.exp: continue to return of -5 +PASS: gdb.base/return.exp: next over call to func2 +PASS: gdb.base/return.exp: correct value returned (integer test) +PASS: gdb.base/return.exp: continue to return of -5.0 +PASS: gdb.base/return.exp: next over call to func3 +FAIL: gdb.base/return.exp: correct value returned double test (known problem with sparc solaris) +Running ./gdb.base/return-nodebug.exp ... +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: signed-char: advance to marker +PASS: gdb.base/return-nodebug.exp: signed-char: full width of the returned result +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: short: advance to marker +PASS: gdb.base/return-nodebug.exp: short: full width of the returned result +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: int: advance to marker +PASS: gdb.base/return-nodebug.exp: int: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long: advance to marker +PASS: gdb.base/return-nodebug.exp: long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long-long: advance to marker +PASS: gdb.base/return-nodebug.exp: long-long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: float: advance to marker +FAIL: gdb.base/return-nodebug.exp: float: full width of the returned result +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: double: advance to marker +FAIL: gdb.base/return-nodebug.exp: double: full width of the returned result +Running ./gdb.base/save-bp.exp ... +PASS: gdb.base/save-bp.exp: add breakpoint commands +PASS: gdb.base/save-bp.exp: dprintf save-bp.c:33,"At foo entry\n" +PASS: gdb.base/save-bp.exp: save breakpoint bps +PASS: gdb.base/save-bp.exp: source bps +PASS: gdb.base/save-bp.exp: info break +Running ./gdb.base/savedregs.exp ... +PASS: gdb.base/savedregs.exp: advance thrower +PASS: gdb.base/savedregs.exp: Get main info frame +PASS: gdb.base/savedregs.exp: handle SIGSEGV pass print nostop +PASS: gdb.base/savedregs.exp: handle SIGILL pass print nostop +PASS: gdb.base/savedregs.exp: advance catcher +PASS: gdb.base/savedregs.exp: Get sigtramp info frame +PASS: gdb.base/savedregs.exp: Get thrower info frame +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: break caller +PASS: gdb.base/savedregs.exp: call caller (1,2,3,4,5,6,7,8) +PASS: gdb.base/savedregs.exp: Get dummy info frame +PASS: gdb.base/savedregs.exp: Get catcher info frame +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: advance callee +PASS: gdb.base/savedregs.exp: Get caller info frame +PASS: gdb.base/savedregs.exp: Check dummy info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check catcher info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains callee caller dummy catcher sigtramp thrower main +Running ./gdb.base/scope.exp ... +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +UNSUPPORTED: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss before run +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal before run +PASS: gdb.base/scope.exp: next over init0() in main +PASS: gdb.base/scope.exp: print filelocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at main +PASS: gdb.base/scope.exp: print filelocal_bss +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_main +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_main +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro +PASS: gdb.base/scope.exp: print foo::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal +PASS: gdb.base/scope.exp: print foo::funclocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro +PASS: gdb.base/scope.exp: print bar::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print filelocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at foo +PASS: gdb.base/scope.exp: print filelocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at foo +PASS: gdb.base/scope.exp: print filelocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at foo +PASS: gdb.base/scope.exp: print funclocal at foo +PASS: gdb.base/scope.exp: print foo::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at foo +PASS: gdb.base/scope.exp: print funclocal_bss at foo +PASS: gdb.base/scope.exp: print foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print funclocal_ro at foo +PASS: gdb.base/scope.exp: print foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print filelocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at bar +PASS: gdb.base/scope.exp: print filelocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at bar +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print foo::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at bar +PASS: gdb.base/scope.exp: print foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print funclocal at bar +PASS: gdb.base/scope.exp: print bar::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at bar +PASS: gdb.base/scope.exp: print funclocal_bss at bar +PASS: gdb.base/scope.exp: print bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: continue to marker2 +PASS: gdb.base/scope.exp: up from marker2 in scopes.exp +PASS: gdb.base/scope.exp: print localval, outer scope +PASS: gdb.base/scope.exp: print localval1, outer scope +PASS: gdb.base/scope.exp: print localval2, outer scope +PASS: gdb.base/scope.exp: print localval3, outer scope +PASS: gdb.base/scope.exp: continue to marker3 in scope.exp +PASS: gdb.base/scope.exp: up from marker3 in scope.exp +PASS: gdb.base/scope.exp: print localval, first nested scope +PASS: gdb.base/scope.exp: print localval1, first nested scope +PASS: gdb.base/scope.exp: print localval2, first nested scope +PASS: gdb.base/scope.exp: print localval3, first nested scope +PASS: gdb.base/scope.exp: continue to marker4 in scope.exp +PASS: gdb.base/scope.exp: up from marker4 in scope.exp +PASS: gdb.base/scope.exp: print localval, innermost scope +PASS: gdb.base/scope.exp: print localval1, innermost scope +PASS: gdb.base/scope.exp: print localval2, innermost scope +PASS: gdb.base/scope.exp: print localval3, innermost scope +PASS: gdb.base/scope.exp: continue to marker1 +PASS: gdb.base/scope.exp: up from marker1 in scope.exp +PASS: gdb.base/scope.exp: 100 auto variables correctly initialized +PASS: gdb.base/scope.exp: args in correct order +Running ./gdb.base/sect-cmd.exp ... +Running ./gdb.base/sepdebug.exp ... +PASS: gdb.base/sepdebug.exp: breakpoint function +PASS: gdb.base/sepdebug.exp: breakpoint quoted function +PASS: gdb.base/sepdebug.exp: breakpoint function in file +PASS: gdb.base/sepdebug.exp: use `list' to establish default source file +PASS: gdb.base/sepdebug.exp: breakpoint line number +PASS: gdb.base/sepdebug.exp: breakpoint duplicate +PASS: gdb.base/sepdebug.exp: breakpoint line number in file +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line while conditional +FAIL: gdb.base/sepdebug.exp: breakpoint info +FAIL: gdb.base/sepdebug.exp: run until function breakpoint +PASS: gdb.base/sepdebug.exp: run until breakpoint set at a line number +PASS: gdb.base/sepdebug.exp: run until file:function(6) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(5) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(4) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(3) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(2) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(1) breakpoint +PASS: gdb.base/sepdebug.exp: run until quoted breakpoint +PASS: gdb.base/sepdebug.exp: run until file:linenum breakpoint +PASS: gdb.base/sepdebug.exp: breakpoint offset +1 +PASS: gdb.base/sepdebug.exp: step onto breakpoint +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function in file +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #2 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #2 +FAIL: gdb.base/sepdebug.exp: Temporary breakpoint info +PASS: gdb.base/sepdebug.exp: catch requires an event name +PASS: gdb.base/sepdebug.exp: set catch fork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch vfork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch exec, never expected to trigger +PASS: gdb.base/sepdebug.exp: set breakpoint pending off +PASS: gdb.base/sepdebug.exp: break on non-existent source line +PASS: gdb.base/sepdebug.exp: until bp_location1 +PASS: gdb.base/sepdebug.exp: break on default location, 1st time +PASS: gdb.base/sepdebug.exp: break on default location, 2nd time +PASS: gdb.base/sepdebug.exp: break on default location, 3rd time +PASS: gdb.base/sepdebug.exp: break on default location, 4th time +PASS: gdb.base/sepdebug.exp: set to-be-silent break bp_location1 +PASS: gdb.base/sepdebug.exp: set silent break bp_location1 +PASS: gdb.base/sepdebug.exp: info silent break bp_location1 +PASS: gdb.base/sepdebug.exp: hit silent break bp_location1 +PASS: gdb.base/sepdebug.exp: stopped for silent break bp_location1 +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/sepdebug.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/sepdebug.exp: step over breakpoint +PASS: gdb.base/sepdebug.exp: clear line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: break marker3 #1 +PASS: gdb.base/sepdebug.exp: break marker3 #2 +PASS: gdb.base/sepdebug.exp: clear marker3 +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/sepdebug.exp: set breakpoint via convenience variable +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/sepdebug.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/sepdebug.exp: set breakpoint on to-be-called function +PASS: gdb.base/sepdebug.exp: hit breakpoint on called function +PASS: gdb.base/sepdebug.exp: backtrace while in called function +PASS: gdb.base/sepdebug.exp: finish from called function +PASS: gdb.base/sepdebug.exp: finish with arguments disallowed +PASS: gdb.base/sepdebug.exp: finish from outermost frame disallowed +PASS: gdb.base/sepdebug.exp: kill program +PASS: gdb.base/sepdebug.exp: break at factorial +PASS: gdb.base/sepdebug.exp: continue to factorial(5) +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5) +PASS: gdb.base/sepdebug.exp: next to recursive call +PASS: gdb.base/sepdebug.exp: next over recursive call +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5.1) +FAIL: gdb.base/sepdebug.exp: setting breakpoint at exit +PASS: gdb.base/sepdebug.exp: debuglink: set separate debug location +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/sepdebug.exp: debuglink: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: CRC mismatch is reported +PASS: gdb.base/sepdebug.exp: build-id support by binutils +PASS: gdb.base/sepdebug.exp: build-id: set separate debug location +PASS: gdb.base/sepdebug.exp: build-id: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/sepdebug.exp: build-id: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: set separate debug location +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until breakpoint set at small function, optimized file +Running ./gdb.base/sep.exp ... +PASS: gdb.base/sep.exp: list using location inside included file +PASS: gdb.base/sep.exp: breakpoint inside included file +Running ./gdb.base/sepsymtab.exp ... +PASS: gdb.base/sepsymtab.exp: info sym main +Running ./gdb.base/set-lang-auto.exp ... +PASS: gdb.base/set-lang-auto.exp: show lang after loading binary +PASS: gdb.base/set-lang-auto.exp: forcing the language to ada +PASS: gdb.base/set-lang-auto.exp: show lang after switching language to ada +PASS: gdb.base/set-lang-auto.exp: switching the language back to auto +PASS: gdb.base/set-lang-auto.exp: show lang after having switched back to auto +Running ./gdb.base/set-noassign.exp ... +PASS: gdb.base/set-noassign.exp: set language ada +PASS: gdb.base/set-noassign.exp: warning for set without assignment +Running ./gdb.base/setshow.exp ... +PASS: gdb.base/setshow.exp: default annotation_level is zero +PASS: gdb.base/setshow.exp: set annotate 2 +PASS: gdb.base/setshow.exp: show annotate 2 +PASS: gdb.base/setshow.exp: annotation_level 2 +PASS: gdb.base/setshow.exp: set annotate 1 +PASS: gdb.base/setshow.exp: show annotate (1) +PASS: gdb.base/setshow.exp: annotation_level 1 +PASS: gdb.base/setshow.exp: set annotate 0 +PASS: gdb.base/setshow.exp: show annotate (0) +PASS: gdb.base/setshow.exp: annotation_level 0 +PASS: gdb.base/setshow.exp: set args ~ +PASS: gdb.base/setshow.exp: show args ~ +PASS: gdb.base/setshow.exp: set args +PASS: gdb.base/setshow.exp: show args +PASS: gdb.base/setshow.exp: set check range on +PASS: gdb.base/setshow.exp: show check range (on) +PASS: gdb.base/setshow.exp: set check range off +PASS: gdb.base/setshow.exp: show check range (off) +PASS: gdb.base/setshow.exp: set check range auto +PASS: gdb.base/setshow.exp: show check range (auto) +PASS: gdb.base/setshow.exp: set check type on +PASS: gdb.base/setshow.exp: show check type (on) +PASS: gdb.base/setshow.exp: set check type off +PASS: gdb.base/setshow.exp: show check type (off) +PASS: gdb.base/setshow.exp: set complaints 100 +PASS: gdb.base/setshow.exp: show complaints (100) +PASS: gdb.base/setshow.exp: set complaints 0 +PASS: gdb.base/setshow.exp: show complaints (0) +PASS: gdb.base/setshow.exp: set confirm off +PASS: gdb.base/setshow.exp: show confirm (off) +PASS: gdb.base/setshow.exp: set confirm on +PASS: gdb.base/setshow.exp: show confirm (on) +PASS: gdb.base/setshow.exp: set editing off +PASS: gdb.base/setshow.exp: show editing (off) +PASS: gdb.base/setshow.exp: set environment FOOBARBAZ +PASS: gdb.base/setshow.exp: show environment FOOBARBAZ +PASS: gdb.base/setshow.exp: set height 100 +PASS: gdb.base/setshow.exp: show height +PASS: gdb.base/setshow.exp: set history expansion on +PASS: gdb.base/setshow.exp: show history expansion +PASS: gdb.base/setshow.exp: set history filename foobar.baz +PASS: gdb.base/setshow.exp: show history filename (foobar.baz) +PASS: gdb.base/setshow.exp: set history save on +PASS: gdb.base/setshow.exp: show history save (on) +PASS: gdb.base/setshow.exp: set history size 100 +PASS: gdb.base/setshow.exp: show history size (100) +PASS: gdb.base/setshow.exp: set language asm +PASS: gdb.base/setshow.exp: show language (asm) +PASS: gdb.base/setshow.exp: set language java +PASS: gdb.base/setshow.exp: show language (java) +PASS: gdb.base/setshow.exp: complete set language minimal +PASS: gdb.base/setshow.exp: set language auto +PASS: gdb.base/setshow.exp: show language (auto) +PASS: gdb.base/setshow.exp: set listsize 100 +PASS: gdb.base/setshow.exp: show listsize (100) +PASS: gdb.base/setshow.exp: set prompt FooBarBaz +PASS: gdb.base/setshow.exp: show prompt FooBarBaz +PASS: gdb.base/setshow.exp: set prompt gdb +PASS: gdb.base/setshow.exp: set radix 11 +PASS: gdb.base/setshow.exp: set radix 16 +PASS: gdb.base/setshow.exp: show radix (16) +PASS: gdb.base/setshow.exp: set radix 10 +PASS: gdb.base/setshow.exp: show radix (10) +PASS: gdb.base/setshow.exp: set width 90 +PASS: gdb.base/setshow.exp: show width (90) +PASS: gdb.base/setshow.exp: set write on +PASS: gdb.base/setshow.exp: show write (on) +PASS: gdb.base/setshow.exp: show user +PASS: gdb.base/setshow.exp: set verbose on +PASS: gdb.base/setshow.exp: show verbose (on) +PASS: gdb.base/setshow.exp: set verbose off +PASS: gdb.base/setshow.exp: show verbose (off) +Running ./gdb.base/setvar.exp ... +PASS: gdb.base/setvar.exp: set print sevenbit-strings +PASS: gdb.base/setvar.exp: set variable char=0 +PASS: gdb.base/setvar.exp: set variable char=1 +PASS: gdb.base/setvar.exp: set variable char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable char=65 ('A') +PASS: gdb.base/setvar.exp: set variable char=97 ('a') +PASS: gdb.base/setvar.exp: set variable char=126 ('~') +PASS: gdb.base/setvar.exp: set variable char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable signed char=0 +PASS: gdb.base/setvar.exp: set variable signed char=1 +PASS: gdb.base/setvar.exp: set variable signed char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable signed char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable signed char=65 ('A') +PASS: gdb.base/setvar.exp: set variable signed char=97 ('a') +PASS: gdb.base/setvar.exp: set variable signed char=126 ('~') +PASS: gdb.base/setvar.exp: set variable signed char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable v_signed_char=-1 +PASS: gdb.base/setvar.exp: set variable signed char=-1 (-1) +PASS: gdb.base/setvar.exp: set variable v_signed_char=0xFF +PASS: gdb.base/setvar.exp: set variable signed char=0xFF (0xFF) +PASS: gdb.base/setvar.exp: set variable unsigned char=0 +PASS: gdb.base/setvar.exp: set variable unsigned char=1 +PASS: gdb.base/setvar.exp: set variable unsigned char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable unsigned char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable unsigned char=65 ('A') +PASS: gdb.base/setvar.exp: set variable unsigned char=97 ('a') +PASS: gdb.base/setvar.exp: set variable unsigned char=126 ('~') +PASS: gdb.base/setvar.exp: set variable unsigned char=255 (8-bit) +PASS: gdb.base/setvar.exp: set variable short=0 +PASS: gdb.base/setvar.exp: set variable short=1 +PASS: gdb.base/setvar.exp: set variable short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed short=0 +PASS: gdb.base/setvar.exp: set variable signed short=1 +PASS: gdb.base/setvar.exp: set variable signed short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned short=0 +PASS: gdb.base/setvar.exp: set variable unsigned short=1 +PASS: gdb.base/setvar.exp: set variable unsigned short=~0 (minus) +PASS: gdb.base/setvar.exp: set variable int=0 +PASS: gdb.base/setvar.exp: set variable int=1 +PASS: gdb.base/setvar.exp: set variable int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed int=0 +PASS: gdb.base/setvar.exp: set variable signed int=1 +PASS: gdb.base/setvar.exp: set variable signed int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned int=0 +PASS: gdb.base/setvar.exp: set variable unsigned int=1 +PASS: gdb.base/setvar.exp: set variable unsigned int=~0 (minus) +PASS: gdb.base/setvar.exp: set variable long=0 +PASS: gdb.base/setvar.exp: set variable long=1 +PASS: gdb.base/setvar.exp: set variable long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed long=0 +PASS: gdb.base/setvar.exp: set variable signed long=1 +PASS: gdb.base/setvar.exp: set variable signed long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned long=0 +PASS: gdb.base/setvar.exp: set variable unsigned long=1 +PASS: gdb.base/setvar.exp: set variable unsigned long=~0 (minus) +PASS: gdb.base/setvar.exp: set variable float=0 +PASS: gdb.base/setvar.exp: set variable float=1 +PASS: gdb.base/setvar.exp: set variable float=-1 (minus) +PASS: gdb.base/setvar.exp: set variable double=0 +PASS: gdb.base/setvar.exp: set variable double=1 +PASS: gdb.base/setvar.exp: set variable double=-1 (minus) +PASS: gdb.base/setvar.exp: set variable char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable short array +PASS: gdb.base/setvar.exp: set variable signed short array +PASS: gdb.base/setvar.exp: set variable unsigned short array +PASS: gdb.base/setvar.exp: set variable int array +PASS: gdb.base/setvar.exp: set variable signed int array +PASS: gdb.base/setvar.exp: set variable unsigned int array +PASS: gdb.base/setvar.exp: set variable long array +PASS: gdb.base/setvar.exp: set variable signed long array +PASS: gdb.base/setvar.exp: set variable unsigned long array +PASS: gdb.base/setvar.exp: set variable float array +PASS: gdb.base/setvar.exp: set variable double array +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable short pointer +PASS: gdb.base/setvar.exp: set variable short pointer (#2) +PASS: gdb.base/setvar.exp: set v_signed_short_pointer=v_signed_short_array +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable signed short pointer +PASS: gdb.base/setvar.exp: print *(v_signed_short_pointer+1) +PASS: gdb.base/setvar.exp: set v_unsigned_short_pointer=v_unsigned_short_array +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable unsigned short pointer +PASS: gdb.base/setvar.exp: print *(v_unsigned_short_pointer+1) +PASS: gdb.base/setvar.exp: set variable int pointer +PASS: gdb.base/setvar.exp: set variable int pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed int pointer +PASS: gdb.base/setvar.exp: set variable signed int pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned int pointer +PASS: gdb.base/setvar.exp: print variable unsigned int pointer+1 +PASS: gdb.base/setvar.exp: set variable long pointer +PASS: gdb.base/setvar.exp: set variable long pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed long pointer +PASS: gdb.base/setvar.exp: set variable signed long pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned long pointer +PASS: gdb.base/setvar.exp: set variable unsigned long pointer (#2) +PASS: gdb.base/setvar.exp: set variable float pointer +PASS: gdb.base/setvar.exp: set variable float pointer (#2) +PASS: gdb.base/setvar.exp: set variable double pointer +PASS: gdb.base/setvar.exp: set variable double pointer (#2) +PASS: gdb.base/setvar.exp: set variable structure char member +PASS: gdb.base/setvar.exp: set variable structure short member +PASS: gdb.base/setvar.exp: set variable structure int member +PASS: gdb.base/setvar.exp: set variable structure long member +PASS: gdb.base/setvar.exp: set variable structure float member +PASS: gdb.base/setvar.exp: set variable structure double member +PASS: gdb.base/setvar.exp: set print structure #1 +PASS: gdb.base/setvar.exp: set print structure #2 +PASS: gdb.base/setvar.exp: set print structure #3 +PASS: gdb.base/setvar.exp: set print structure #4 +PASS: gdb.base/setvar.exp: print sef.field=sm1 +PASS: gdb.base/setvar.exp: print sef.field (sm1) +PASS: gdb.base/setvar.exp: print sef.field=s1 +PASS: gdb.base/setvar.exp: print sef.field (s1) +PASS: gdb.base/setvar.exp: print uef.field=u2 +PASS: gdb.base/setvar.exp: print uef.field (u2) +PASS: gdb.base/setvar.exp: print uef.field=u1 +PASS: gdb.base/setvar.exp: print uef.field (u1) +PASS: gdb.base/setvar.exp: print sef.field=7 +PASS: gdb.base/setvar.exp: print uef.field=6 +Running ./gdb.base/shell.exp ... +PASS: gdb.base/shell.exp: shell echo foo +PASS: gdb.base/shell.exp: ! echo foo +PASS: gdb.base/shell.exp: !echo foo +Running ./gdb.base/shlib-call.exp ... +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +FAIL: gdb.base/shlib-call.exp: next to shr1 +FAIL: gdb.base/shlib-call.exp: print g +FAIL: gdb.base/shlib-call.exp: print g +FAIL: gdb.base/shlib-call.exp: breakpoint function shr2 (got interactive prompt) +FAIL: gdb.base/shlib-call.exp: run until breakpoint set at a function (the program exited) +FAIL: gdb.base/shlib-call.exp: print mainshr1(1) from shlib func +FAIL: gdb.base/shlib-call.exp: step out of shr2 to main (the program is no longer running) +FAIL: gdb.base/shlib-call.exp: print mainshr1(1) +FAIL: gdb.base/shlib-call.exp: step into mainshr1 (the program is no longer running) +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +Running ./gdb.base/shreloc.exp ... +FAIL: gdb.base/shreloc.exp: get address of fn_1 +FAIL: gdb.base/shreloc.exp: get address of fn_2 +FAIL: gdb.base/shreloc.exp: relocated extern functions have different addresses +FAIL: gdb.base/shreloc.exp: get address of extern_var_1 +FAIL: gdb.base/shreloc.exp: get address of extern_var_2 +FAIL: gdb.base/shreloc.exp: relocated extern variables have different addresses +FAIL: gdb.base/shreloc.exp: get address of static_var_1 +FAIL: gdb.base/shreloc.exp: get address of static_var_2 +FAIL: gdb.base/shreloc.exp: relocated static variables have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs static_var_[12] +FAIL: gdb.base/shreloc.exp: (msymbol) relocated static vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs extern_var_[12] +FAIL: gdb.base/shreloc.exp: (msymbol) relocated extern vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs fn_[12] +FAIL: gdb.base/shreloc.exp: (msymbol) relocated functions have different addresses +Running ./gdb.base/sigall.exp ... +PASS: gdb.base/sigall.exp: handle SIGABRT stop print +PASS: gdb.base/sigall.exp: b handle_ABRT +PASS: gdb.base/sigall.exp: b gen_HUP +PASS: gdb.base/sigall.exp: get signal ABRT +PASS: gdb.base/sigall.exp: send signal ABRT +PASS: gdb.base/sigall.exp: advance to HUP +PASS: gdb.base/sigall.exp: handle SIGHUP stop print +PASS: gdb.base/sigall.exp: b handle_HUP +PASS: gdb.base/sigall.exp: b gen_QUIT +PASS: gdb.base/sigall.exp: get signal HUP +PASS: gdb.base/sigall.exp: send signal HUP +PASS: gdb.base/sigall.exp: advance to QUIT +PASS: gdb.base/sigall.exp: handle SIGQUIT stop print +PASS: gdb.base/sigall.exp: b handle_QUIT +PASS: gdb.base/sigall.exp: b gen_ILL +PASS: gdb.base/sigall.exp: get signal QUIT +PASS: gdb.base/sigall.exp: send signal QUIT +PASS: gdb.base/sigall.exp: advance to ILL +PASS: gdb.base/sigall.exp: handle SIGILL stop print +PASS: gdb.base/sigall.exp: b handle_ILL +PASS: gdb.base/sigall.exp: b gen_EMT +PASS: gdb.base/sigall.exp: get signal ILL +PASS: gdb.base/sigall.exp: send signal ILL +PASS: gdb.base/sigall.exp: advance to EMT +PASS: gdb.base/sigall.exp: handle SIGEMT stop print +PASS: gdb.base/sigall.exp: b handle_EMT +PASS: gdb.base/sigall.exp: b gen_FPE +PASS: gdb.base/sigall.exp: send signal EMT +PASS: gdb.base/sigall.exp: advance to FPE +PASS: gdb.base/sigall.exp: handle SIGFPE stop print +PASS: gdb.base/sigall.exp: b handle_FPE +PASS: gdb.base/sigall.exp: b gen_BUS +PASS: gdb.base/sigall.exp: get signal FPE +PASS: gdb.base/sigall.exp: send signal FPE +PASS: gdb.base/sigall.exp: advance to BUS +PASS: gdb.base/sigall.exp: handle SIGBUS stop print +PASS: gdb.base/sigall.exp: b handle_BUS +PASS: gdb.base/sigall.exp: b gen_SEGV +PASS: gdb.base/sigall.exp: get signal BUS +PASS: gdb.base/sigall.exp: send signal BUS +PASS: gdb.base/sigall.exp: advance to SEGV +PASS: gdb.base/sigall.exp: handle SIGSEGV stop print +PASS: gdb.base/sigall.exp: b handle_SEGV +PASS: gdb.base/sigall.exp: b gen_SYS +PASS: gdb.base/sigall.exp: get signal SEGV +PASS: gdb.base/sigall.exp: send signal SEGV +PASS: gdb.base/sigall.exp: advance to SYS +PASS: gdb.base/sigall.exp: handle SIGSYS stop print +PASS: gdb.base/sigall.exp: b handle_SYS +PASS: gdb.base/sigall.exp: b gen_PIPE +PASS: gdb.base/sigall.exp: get signal SYS +PASS: gdb.base/sigall.exp: send signal SYS +PASS: gdb.base/sigall.exp: advance to PIPE +PASS: gdb.base/sigall.exp: handle SIGPIPE stop print +PASS: gdb.base/sigall.exp: b handle_PIPE +PASS: gdb.base/sigall.exp: b gen_ALRM +PASS: gdb.base/sigall.exp: get signal PIPE +PASS: gdb.base/sigall.exp: send signal PIPE +PASS: gdb.base/sigall.exp: advance to ALRM +PASS: gdb.base/sigall.exp: handle SIGALRM stop print +PASS: gdb.base/sigall.exp: b handle_ALRM +PASS: gdb.base/sigall.exp: b gen_URG +PASS: gdb.base/sigall.exp: get signal ALRM +PASS: gdb.base/sigall.exp: send signal ALRM +PASS: gdb.base/sigall.exp: advance to URG +PASS: gdb.base/sigall.exp: handle SIGURG stop print +PASS: gdb.base/sigall.exp: b handle_URG +PASS: gdb.base/sigall.exp: b gen_TSTP +PASS: gdb.base/sigall.exp: get signal URG +PASS: gdb.base/sigall.exp: send signal URG +PASS: gdb.base/sigall.exp: advance to TSTP +PASS: gdb.base/sigall.exp: handle SIGTSTP stop print +PASS: gdb.base/sigall.exp: b handle_TSTP +PASS: gdb.base/sigall.exp: b gen_CONT +PASS: gdb.base/sigall.exp: get signal TSTP +PASS: gdb.base/sigall.exp: send signal TSTP +PASS: gdb.base/sigall.exp: advance to CONT +PASS: gdb.base/sigall.exp: handle SIGCONT stop print +PASS: gdb.base/sigall.exp: b handle_CONT +PASS: gdb.base/sigall.exp: b gen_CHLD +PASS: gdb.base/sigall.exp: get signal CONT +PASS: gdb.base/sigall.exp: send signal CONT +PASS: gdb.base/sigall.exp: advance to CHLD +PASS: gdb.base/sigall.exp: handle SIGCHLD stop print +PASS: gdb.base/sigall.exp: b handle_CHLD +PASS: gdb.base/sigall.exp: b gen_TTIN +PASS: gdb.base/sigall.exp: get signal CHLD +PASS: gdb.base/sigall.exp: send signal CHLD +PASS: gdb.base/sigall.exp: advance to TTIN +PASS: gdb.base/sigall.exp: handle SIGTTIN stop print +PASS: gdb.base/sigall.exp: b handle_TTIN +PASS: gdb.base/sigall.exp: b gen_TTOU +PASS: gdb.base/sigall.exp: get signal TTIN +PASS: gdb.base/sigall.exp: send signal TTIN +PASS: gdb.base/sigall.exp: advance to TTOU +PASS: gdb.base/sigall.exp: handle SIGTTOU stop print +PASS: gdb.base/sigall.exp: b handle_TTOU +PASS: gdb.base/sigall.exp: b gen_IO +PASS: gdb.base/sigall.exp: get signal TTOU +PASS: gdb.base/sigall.exp: send signal TTOU +PASS: gdb.base/sigall.exp: advance to IO +PASS: gdb.base/sigall.exp: handle SIGIO stop print +PASS: gdb.base/sigall.exp: b handle_IO +PASS: gdb.base/sigall.exp: b gen_XCPU +PASS: gdb.base/sigall.exp: get signal IO +PASS: gdb.base/sigall.exp: send signal IO +PASS: gdb.base/sigall.exp: advance to XCPU +PASS: gdb.base/sigall.exp: handle SIGXCPU stop print +PASS: gdb.base/sigall.exp: b handle_XCPU +PASS: gdb.base/sigall.exp: b gen_XFSZ +PASS: gdb.base/sigall.exp: get signal XCPU +PASS: gdb.base/sigall.exp: send signal XCPU +PASS: gdb.base/sigall.exp: advance to XFSZ +PASS: gdb.base/sigall.exp: handle SIGXFSZ stop print +PASS: gdb.base/sigall.exp: b handle_XFSZ +PASS: gdb.base/sigall.exp: b gen_VTALRM +PASS: gdb.base/sigall.exp: get signal XFSZ +PASS: gdb.base/sigall.exp: send signal XFSZ +PASS: gdb.base/sigall.exp: advance to VTALRM +PASS: gdb.base/sigall.exp: handle SIGVTALRM stop print +PASS: gdb.base/sigall.exp: b handle_VTALRM +PASS: gdb.base/sigall.exp: b gen_PROF +PASS: gdb.base/sigall.exp: get signal VTALRM +PASS: gdb.base/sigall.exp: send signal VTALRM +PASS: gdb.base/sigall.exp: advance to PROF +PASS: gdb.base/sigall.exp: handle SIGPROF stop print +PASS: gdb.base/sigall.exp: b handle_PROF +PASS: gdb.base/sigall.exp: b gen_WINCH +PASS: gdb.base/sigall.exp: get signal PROF +PASS: gdb.base/sigall.exp: send signal PROF +PASS: gdb.base/sigall.exp: advance to WINCH +PASS: gdb.base/sigall.exp: handle SIGWINCH stop print +PASS: gdb.base/sigall.exp: b handle_WINCH +PASS: gdb.base/sigall.exp: b gen_LOST +PASS: gdb.base/sigall.exp: get signal WINCH +PASS: gdb.base/sigall.exp: send signal WINCH +PASS: gdb.base/sigall.exp: advance to LOST +PASS: gdb.base/sigall.exp: handle SIGLOST stop print +PASS: gdb.base/sigall.exp: b handle_LOST +PASS: gdb.base/sigall.exp: b gen_USR1 +PASS: gdb.base/sigall.exp: send signal LOST +PASS: gdb.base/sigall.exp: advance to USR1 +PASS: gdb.base/sigall.exp: handle SIGUSR1 stop print +PASS: gdb.base/sigall.exp: b handle_USR1 +PASS: gdb.base/sigall.exp: b gen_USR2 +PASS: gdb.base/sigall.exp: get signal USR1 +PASS: gdb.base/sigall.exp: send signal USR1 +PASS: gdb.base/sigall.exp: advance to USR2 +PASS: gdb.base/sigall.exp: handle SIGUSR2 stop print +PASS: gdb.base/sigall.exp: b handle_USR2 +PASS: gdb.base/sigall.exp: b gen_PWR +PASS: gdb.base/sigall.exp: get signal USR2 +PASS: gdb.base/sigall.exp: send signal USR2 +PASS: gdb.base/sigall.exp: advance to PWR +PASS: gdb.base/sigall.exp: handle SIGPWR stop print +PASS: gdb.base/sigall.exp: b handle_PWR +PASS: gdb.base/sigall.exp: b gen_POLL +PASS: gdb.base/sigall.exp: get signal PWR +PASS: gdb.base/sigall.exp: send signal PWR +PASS: gdb.base/sigall.exp: advance to POLL +PASS: gdb.base/sigall.exp: handle SIGPOLL stop print +PASS: gdb.base/sigall.exp: b handle_POLL +PASS: gdb.base/sigall.exp: b gen_WIND +PASS: gdb.base/sigall.exp: send signal POLL +PASS: gdb.base/sigall.exp: advance to WIND +PASS: gdb.base/sigall.exp: handle SIGWIND stop print +PASS: gdb.base/sigall.exp: b handle_WIND +PASS: gdb.base/sigall.exp: b gen_PHONE +PASS: gdb.base/sigall.exp: send signal WIND +PASS: gdb.base/sigall.exp: advance to PHONE +PASS: gdb.base/sigall.exp: handle SIGPHONE stop print +PASS: gdb.base/sigall.exp: b handle_PHONE +PASS: gdb.base/sigall.exp: b gen_WAITING +PASS: gdb.base/sigall.exp: send signal PHONE +PASS: gdb.base/sigall.exp: advance to WAITING +PASS: gdb.base/sigall.exp: handle SIGWAITING stop print +PASS: gdb.base/sigall.exp: b handle_WAITING +PASS: gdb.base/sigall.exp: b gen_LWP +PASS: gdb.base/sigall.exp: send signal WAITING +PASS: gdb.base/sigall.exp: advance to LWP +PASS: gdb.base/sigall.exp: handle SIGLWP stop print +PASS: gdb.base/sigall.exp: b handle_LWP +PASS: gdb.base/sigall.exp: b gen_DANGER +PASS: gdb.base/sigall.exp: send signal LWP +PASS: gdb.base/sigall.exp: advance to DANGER +PASS: gdb.base/sigall.exp: handle SIGDANGER stop print +PASS: gdb.base/sigall.exp: b handle_DANGER +PASS: gdb.base/sigall.exp: b gen_GRANT +PASS: gdb.base/sigall.exp: send signal DANGER +PASS: gdb.base/sigall.exp: advance to GRANT +PASS: gdb.base/sigall.exp: handle SIGGRANT stop print +PASS: gdb.base/sigall.exp: b handle_GRANT +PASS: gdb.base/sigall.exp: b gen_RETRACT +PASS: gdb.base/sigall.exp: send signal GRANT +PASS: gdb.base/sigall.exp: advance to RETRACT +PASS: gdb.base/sigall.exp: handle SIGRETRACT stop print +PASS: gdb.base/sigall.exp: b handle_RETRACT +PASS: gdb.base/sigall.exp: b gen_MSG +PASS: gdb.base/sigall.exp: send signal RETRACT +PASS: gdb.base/sigall.exp: advance to MSG +PASS: gdb.base/sigall.exp: handle SIGMSG stop print +PASS: gdb.base/sigall.exp: b handle_MSG +PASS: gdb.base/sigall.exp: b gen_SOUND +PASS: gdb.base/sigall.exp: send signal MSG +PASS: gdb.base/sigall.exp: advance to SOUND +PASS: gdb.base/sigall.exp: handle SIGSOUND stop print +PASS: gdb.base/sigall.exp: b handle_SOUND +PASS: gdb.base/sigall.exp: b gen_SAK +PASS: gdb.base/sigall.exp: send signal SOUND +PASS: gdb.base/sigall.exp: advance to SAK +PASS: gdb.base/sigall.exp: handle SIGSAK stop print +PASS: gdb.base/sigall.exp: b handle_SAK +PASS: gdb.base/sigall.exp: b gen_PRIO +PASS: gdb.base/sigall.exp: send signal SAK +PASS: gdb.base/sigall.exp: advance to PRIO +PASS: gdb.base/sigall.exp: handle SIGPRIO stop print +PASS: gdb.base/sigall.exp: b handle_PRIO +PASS: gdb.base/sigall.exp: b gen_33 +PASS: gdb.base/sigall.exp: send signal PRIO +PASS: gdb.base/sigall.exp: advance to 33 +PASS: gdb.base/sigall.exp: handle SIG33 stop print +PASS: gdb.base/sigall.exp: b handle_33 +PASS: gdb.base/sigall.exp: b gen_34 +PASS: gdb.base/sigall.exp: send signal 33 +PASS: gdb.base/sigall.exp: advance to 34 +PASS: gdb.base/sigall.exp: handle SIG34 stop print +PASS: gdb.base/sigall.exp: b handle_34 +PASS: gdb.base/sigall.exp: b gen_35 +PASS: gdb.base/sigall.exp: send signal 34 +PASS: gdb.base/sigall.exp: advance to 35 +PASS: gdb.base/sigall.exp: handle SIG35 stop print +PASS: gdb.base/sigall.exp: b handle_35 +PASS: gdb.base/sigall.exp: b gen_36 +PASS: gdb.base/sigall.exp: send signal 35 +PASS: gdb.base/sigall.exp: advance to 36 +PASS: gdb.base/sigall.exp: handle SIG36 stop print +PASS: gdb.base/sigall.exp: b handle_36 +PASS: gdb.base/sigall.exp: b gen_37 +PASS: gdb.base/sigall.exp: send signal 36 +PASS: gdb.base/sigall.exp: advance to 37 +PASS: gdb.base/sigall.exp: handle SIG37 stop print +PASS: gdb.base/sigall.exp: b handle_37 +PASS: gdb.base/sigall.exp: b gen_38 +PASS: gdb.base/sigall.exp: send signal 37 +PASS: gdb.base/sigall.exp: advance to 38 +PASS: gdb.base/sigall.exp: handle SIG38 stop print +PASS: gdb.base/sigall.exp: b handle_38 +PASS: gdb.base/sigall.exp: b gen_39 +PASS: gdb.base/sigall.exp: send signal 38 +PASS: gdb.base/sigall.exp: advance to 39 +PASS: gdb.base/sigall.exp: handle SIG39 stop print +PASS: gdb.base/sigall.exp: b handle_39 +PASS: gdb.base/sigall.exp: b gen_40 +PASS: gdb.base/sigall.exp: send signal 39 +PASS: gdb.base/sigall.exp: advance to 40 +PASS: gdb.base/sigall.exp: handle SIG40 stop print +PASS: gdb.base/sigall.exp: b handle_40 +PASS: gdb.base/sigall.exp: b gen_41 +PASS: gdb.base/sigall.exp: send signal 40 +PASS: gdb.base/sigall.exp: advance to 41 +PASS: gdb.base/sigall.exp: handle SIG41 stop print +PASS: gdb.base/sigall.exp: b handle_41 +PASS: gdb.base/sigall.exp: b gen_42 +PASS: gdb.base/sigall.exp: send signal 41 +PASS: gdb.base/sigall.exp: advance to 42 +PASS: gdb.base/sigall.exp: handle SIG42 stop print +PASS: gdb.base/sigall.exp: b handle_42 +PASS: gdb.base/sigall.exp: b gen_43 +PASS: gdb.base/sigall.exp: send signal 42 +PASS: gdb.base/sigall.exp: advance to 43 +PASS: gdb.base/sigall.exp: handle SIG43 stop print +PASS: gdb.base/sigall.exp: b handle_43 +PASS: gdb.base/sigall.exp: b gen_44 +PASS: gdb.base/sigall.exp: send signal 43 +PASS: gdb.base/sigall.exp: advance to 44 +PASS: gdb.base/sigall.exp: handle SIG44 stop print +PASS: gdb.base/sigall.exp: b handle_44 +PASS: gdb.base/sigall.exp: b gen_45 +PASS: gdb.base/sigall.exp: send signal 44 +PASS: gdb.base/sigall.exp: advance to 45 +PASS: gdb.base/sigall.exp: handle SIG45 stop print +PASS: gdb.base/sigall.exp: b handle_45 +PASS: gdb.base/sigall.exp: b gen_46 +PASS: gdb.base/sigall.exp: send signal 45 +PASS: gdb.base/sigall.exp: advance to 46 +PASS: gdb.base/sigall.exp: handle SIG46 stop print +PASS: gdb.base/sigall.exp: b handle_46 +PASS: gdb.base/sigall.exp: b gen_47 +PASS: gdb.base/sigall.exp: send signal 46 +PASS: gdb.base/sigall.exp: advance to 47 +PASS: gdb.base/sigall.exp: handle SIG47 stop print +PASS: gdb.base/sigall.exp: b handle_47 +PASS: gdb.base/sigall.exp: b gen_48 +PASS: gdb.base/sigall.exp: send signal 47 +PASS: gdb.base/sigall.exp: advance to 48 +PASS: gdb.base/sigall.exp: handle SIG48 stop print +PASS: gdb.base/sigall.exp: b handle_48 +PASS: gdb.base/sigall.exp: b gen_49 +PASS: gdb.base/sigall.exp: send signal 48 +PASS: gdb.base/sigall.exp: advance to 49 +PASS: gdb.base/sigall.exp: handle SIG49 stop print +PASS: gdb.base/sigall.exp: b handle_49 +PASS: gdb.base/sigall.exp: b gen_50 +PASS: gdb.base/sigall.exp: send signal 49 +PASS: gdb.base/sigall.exp: advance to 50 +PASS: gdb.base/sigall.exp: handle SIG50 stop print +PASS: gdb.base/sigall.exp: b handle_50 +PASS: gdb.base/sigall.exp: b gen_51 +PASS: gdb.base/sigall.exp: send signal 50 +PASS: gdb.base/sigall.exp: advance to 51 +PASS: gdb.base/sigall.exp: handle SIG51 stop print +PASS: gdb.base/sigall.exp: b handle_51 +PASS: gdb.base/sigall.exp: b gen_52 +PASS: gdb.base/sigall.exp: send signal 51 +PASS: gdb.base/sigall.exp: advance to 52 +PASS: gdb.base/sigall.exp: handle SIG52 stop print +PASS: gdb.base/sigall.exp: b handle_52 +PASS: gdb.base/sigall.exp: b gen_53 +PASS: gdb.base/sigall.exp: send signal 52 +PASS: gdb.base/sigall.exp: advance to 53 +PASS: gdb.base/sigall.exp: handle SIG53 stop print +PASS: gdb.base/sigall.exp: b handle_53 +PASS: gdb.base/sigall.exp: b gen_54 +PASS: gdb.base/sigall.exp: send signal 53 +PASS: gdb.base/sigall.exp: advance to 54 +PASS: gdb.base/sigall.exp: handle SIG54 stop print +PASS: gdb.base/sigall.exp: b handle_54 +PASS: gdb.base/sigall.exp: b gen_55 +PASS: gdb.base/sigall.exp: send signal 54 +PASS: gdb.base/sigall.exp: advance to 55 +PASS: gdb.base/sigall.exp: handle SIG55 stop print +PASS: gdb.base/sigall.exp: b handle_55 +PASS: gdb.base/sigall.exp: b gen_56 +PASS: gdb.base/sigall.exp: send signal 55 +PASS: gdb.base/sigall.exp: advance to 56 +PASS: gdb.base/sigall.exp: handle SIG56 stop print +PASS: gdb.base/sigall.exp: b handle_56 +PASS: gdb.base/sigall.exp: b gen_57 +PASS: gdb.base/sigall.exp: send signal 56 +PASS: gdb.base/sigall.exp: advance to 57 +PASS: gdb.base/sigall.exp: handle SIG57 stop print +PASS: gdb.base/sigall.exp: b handle_57 +PASS: gdb.base/sigall.exp: b gen_58 +PASS: gdb.base/sigall.exp: send signal 57 +PASS: gdb.base/sigall.exp: advance to 58 +PASS: gdb.base/sigall.exp: handle SIG58 stop print +PASS: gdb.base/sigall.exp: b handle_58 +PASS: gdb.base/sigall.exp: b gen_59 +PASS: gdb.base/sigall.exp: send signal 58 +PASS: gdb.base/sigall.exp: advance to 59 +PASS: gdb.base/sigall.exp: handle SIG59 stop print +PASS: gdb.base/sigall.exp: b handle_59 +PASS: gdb.base/sigall.exp: b gen_60 +PASS: gdb.base/sigall.exp: send signal 59 +PASS: gdb.base/sigall.exp: advance to 60 +PASS: gdb.base/sigall.exp: handle SIG60 stop print +PASS: gdb.base/sigall.exp: b handle_60 +PASS: gdb.base/sigall.exp: b gen_61 +PASS: gdb.base/sigall.exp: send signal 60 +PASS: gdb.base/sigall.exp: advance to 61 +PASS: gdb.base/sigall.exp: handle SIG61 stop print +PASS: gdb.base/sigall.exp: b handle_61 +PASS: gdb.base/sigall.exp: b gen_62 +PASS: gdb.base/sigall.exp: send signal 61 +PASS: gdb.base/sigall.exp: advance to 62 +PASS: gdb.base/sigall.exp: handle SIG62 stop print +PASS: gdb.base/sigall.exp: b handle_62 +PASS: gdb.base/sigall.exp: b gen_63 +PASS: gdb.base/sigall.exp: send signal 62 +PASS: gdb.base/sigall.exp: advance to 63 +PASS: gdb.base/sigall.exp: handle SIG63 stop print +PASS: gdb.base/sigall.exp: b handle_63 +PASS: gdb.base/sigall.exp: b gen_TERM +PASS: gdb.base/sigall.exp: send signal 63 +PASS: gdb.base/sigall.exp: advance to TERM +PASS: gdb.base/sigall.exp: handle SIGTERM stop print +PASS: gdb.base/sigall.exp: b handle_TERM +PASS: gdb.base/sigall.exp: get signal TERM +PASS: gdb.base/sigall.exp: send signal TERM +FAIL: gdb.base/sigall.exp: setting breakpoint at exit +Running ./gdb.base/sigaltstack.exp ... +PASS: gdb.base/sigaltstack.exp: handle SIGALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGVTALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGPROF print pass nostop +PASS: gdb.base/sigaltstack.exp: break catcher if level == INNER +PASS: gdb.base/sigaltstack.exp: continue to catch +PASS: gdb.base/sigaltstack.exp: next +PASS: gdb.base/sigaltstack.exp: backtrace +FAIL: gdb.base/sigaltstack.exp: finish from catch LEAF +FAIL: gdb.base/sigaltstack.exp: finish to throw INNER +FAIL: gdb.base/sigaltstack.exp: finish to catch INNER (GDB internal error) +FAIL: gdb.base/sigaltstack.exp: finish from catch INNER (GDB internal error) +FAIL: gdb.base/sigaltstack.exp: finish to OUTER (GDB internal error) +FAIL: gdb.base/sigaltstack.exp: finish to catch MAIN (GDB internal error) +FAIL: gdb.base/sigaltstack.exp: finish to MAIN (GDB internal error) +Running ./gdb.base/sigbpt.exp ... +PASS: gdb.base/sigbpt.exp: break keeper +PASS: gdb.base/sigbpt.exp: display/i $pc +PASS: gdb.base/sigbpt.exp: advance to the bowler +PASS: gdb.base/sigbpt.exp: stepping to fault +PASS: gdb.base/sigbpt.exp: get insn after fault +PASS: gdb.base/sigbpt.exp: Verify that SIGSEGV occurs at the last STEPI insn +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi; nopass SIGSEGV +KFAIL: gdb.base/sigbpt.exp: stepi; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp before segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp at segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 1 of 2 +KFAIL: gdb.base/sigbpt.exp: stepi bp before and at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; continue to keeper +PASS: gdb.base/sigbpt.exp: cont; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; set breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: cont; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont; stepi fault +PASS: gdb.base/sigbpt.exp: cont; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont bp after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 2 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 2 of 3 +Running ./gdb.base/sigchld.exp ... +PASS: gdb.base/sigchld.exp: set breakpoint at success exit +PASS: gdb.base/sigchld.exp: set breakpoint at failure exit +PASS: gdb.base/sigchld.exp: SIGCHLD blocked in inferior +Running ./gdb.base/siginfo-addr.exp ... +Running ./gdb.base/siginfo.exp ... +PASS: gdb.base/siginfo.exp: display/i $pc +PASS: gdb.base/siginfo.exp: break handler +PASS: gdb.base/siginfo.exp: continue to stepi handler +PASS: gdb.base/siginfo.exp: backtrace for nexti +PASS: gdb.base/siginfo.exp: step out of handler +Running ./gdb.base/siginfo-infcall.exp ... +PASS: gdb.base/siginfo-infcall.exp: continue to SIGUSR1 +PASS: gdb.base/siginfo-infcall.exp: p callme () +PASS: gdb.base/siginfo-infcall.exp: continue to the handler +Running ./gdb.base/siginfo-obj.exp ... +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: save a core file +PASS: gdb.base/siginfo-obj.exp: Extract si_addr +PASS: gdb.base/siginfo-obj.exp: Extract si_errno +PASS: gdb.base/siginfo-obj.exp: Extract si_code +PASS: gdb.base/siginfo-obj.exp: Extract si_signo +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr = 0x666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno = 666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_code = 999 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo = 11 +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +PASS: gdb.base/siginfo-obj.exp: core siginfo-obj.gcore +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo from core file +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno from core file +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_code from core file +PASS: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr from core file +Running ./gdb.base/siginfo-thread.exp ... +PASS: gdb.base/siginfo-thread.exp: successfully compiled posix threads test case +PASS: gdb.base/siginfo-thread.exp: continue to signal +PASS: gdb.base/siginfo-thread.exp: save a core file +PASS: gdb.base/siginfo-thread.exp: Extract si_addr +PASS: gdb.base/siginfo-thread.exp: Extract si_errno +PASS: gdb.base/siginfo-thread.exp: Extract si_code +PASS: gdb.base/siginfo-thread.exp: Extract si_signo +PASS: gdb.base/siginfo-thread.exp: break 39 +PASS: gdb.base/siginfo-thread.exp: continue to handler +PASS: gdb.base/siginfo-thread.exp: p ssi_addr +PASS: gdb.base/siginfo-thread.exp: p ssi_errno +PASS: gdb.base/siginfo-thread.exp: p ssi_code +PASS: gdb.base/siginfo-thread.exp: p ssi_signo +PASS: gdb.base/siginfo-thread.exp: thread 1 +PASS: gdb.base/siginfo-thread.exp: test signal in main thread +PASS: gdb.base/siginfo-thread.exp: core siginfo-thread.gcore +PASS: gdb.base/siginfo-thread.exp: p $_siginfo.si_signo from core file +PASS: gdb.base/siginfo-thread.exp: p $_siginfo.si_errno from core file +PASS: gdb.base/siginfo-thread.exp: p $_siginfo.si_code from core file +PASS: gdb.base/siginfo-thread.exp: p $_siginfo._sifields._sigfault.si_addr from core file +PASS: gdb.base/siginfo-thread.exp: set variable $count = 0 +PASS: gdb.base/siginfo-thread.exp: select thread 1 with core file +PASS: gdb.base/siginfo-thread.exp: update counter in thread 1 +PASS: gdb.base/siginfo-thread.exp: select thread 2 with core file +PASS: gdb.base/siginfo-thread.exp: update counter in thread 2 +PASS: gdb.base/siginfo-thread.exp: print $count +Running ./gdb.base/signals.exp ... +PASS: gdb.base/signals.exp: handle all print +PASS: gdb.base/signals.exp: set variable count = 0 +PASS: gdb.base/signals.exp: break handler if 0 +PASS: gdb.base/signals.exp: set $handler_breakpoint_number = $bpnum +PASS: gdb.base/signals.exp: next to signal +PASS: gdb.base/signals.exp: next to alarm #1 +PASS: gdb.base/signals.exp: next to ++count #1 +PASS: gdb.base/signals.exp: p func1 () #1 +PASS: gdb.base/signals.exp: p count #1 +PASS: gdb.base/signals.exp: condition $handler_breakpoint_number +PASS: gdb.base/signals.exp: next to alarm #2 +PASS: gdb.base/signals.exp: next to ++count #2 +PASS: gdb.base/signals.exp: p func1 () #2 +PASS: gdb.base/signals.exp: backtrace from handler when calling func1 +PASS: gdb.base/signals.exp: continue +PASS: gdb.base/signals.exp: p count #2 +PASS: gdb.base/signals.exp: info signals +PASS: gdb.base/signals.exp: info signal SIGTRAP +PASS: gdb.base/signals.exp: info signal 5 +PASS: gdb.base/signals.exp: handle without arguments +PASS: gdb.base/signals.exp: handle with bogus SIG +PASS: gdb.base/signals.exp: handle SIG with bogus action +PASS: gdb.base/signals.exp: handle SIG with multiple conflicting actions +PASS: gdb.base/signals.exp: handle SIG parses all legal actions +PASS: gdb.base/signals.exp: handle multiple SIGs +PASS: gdb.base/signals.exp: override SIGTRAP +PASS: gdb.base/signals.exp: invalid signal number rejected +PASS: gdb.base/signals.exp: handle multiple SIGs via integer range +PASS: gdb.base/signals.exp: handle multiple SIGs via reverse integer range +PASS: gdb.base/signals.exp: override SIGINT +PASS: gdb.base/signals.exp: signal without arguments disallowed +PASS: gdb.base/signals.exp: signal SIGUSR1 +PASS: gdb.base/signals.exp: backtrace for SIGUSR1 +Running ./gdb.base/signest.exp ... +PASS: gdb.base/signest.exp: continue to fault +PASS: gdb.base/signest.exp: set conditional breakpoint +PASS: gdb.base/signest.exp: pass SIGSEGV +PASS: gdb.base/signest.exp: pass SIGBUS +PASS: gdb.base/signest.exp: run through nested faults +Running ./gdb.base/signull.exp ... +PASS: gdb.base/signull.exp: set for function pointer probe +PASS: gdb.base/signull.exp: probe function pointer (function entry-point) +PASS: gdb.base/signull.exp: rerun to main +PASS: gdb.base/signull.exp: break bowler +PASS: gdb.base/signull.exp: break keeper +PASS: gdb.base/signull.exp: handle SIGSEGV +PASS: gdb.base/signull.exp: handle SIGBUS +PASS: gdb.base/signull.exp: data read; start with the bowler +PASS: gdb.base/signull.exp: data read; select the pointer type +PASS: gdb.base/signull.exp: data read; take the SIGSEGV +PASS: gdb.base/signull.exp: data read; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data read; continue to the keeper +PASS: gdb.base/signull.exp: data read; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: data write; start with the bowler +PASS: gdb.base/signull.exp: data write; select the pointer type +PASS: gdb.base/signull.exp: data write; take the SIGSEGV +PASS: gdb.base/signull.exp: data write; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data write; continue to the keeper +PASS: gdb.base/signull.exp: data write; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: code; start with the bowler +PASS: gdb.base/signull.exp: code; select the pointer type +PASS: gdb.base/signull.exp: code; take the SIGSEGV +PASS: gdb.base/signull.exp: code; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: code; continue to the keeper +PASS: gdb.base/signull.exp: code; backtrace from keeper through SIGSEGV +Running ./gdb.base/sigrepeat.exp ... +PASS: gdb.base/sigrepeat.exp: advance to infinite loop +PASS: gdb.base/sigrepeat.exp: next +Running ./gdb.base/sigstep.exp ... +PASS: gdb.base/sigstep.exp: display/i $pc +PASS: gdb.base/sigstep.exp: break handler +PASS: gdb.base/sigstep.exp: continue to stepi handler +PASS: gdb.base/sigstep.exp: backtrace for nexti +PASS: gdb.base/sigstep.exp: step from handler; continue to handler +PASS: gdb.base/sigstep.exp: step from handler; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; continue to handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: next from handler; continue to handler +PASS: gdb.base/sigstep.exp: next from handler; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; continue to handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: finish from handleri; continue to handler +FAIL: gdb.base/sigstep.exp: finish from handleri; leave handler +FAIL: gdb.base/sigstep.exp: finish from handleri; leave signal trampoline +FAIL: gdb.base/sigstep.exp: return from handleri; continue to handler +FAIL: gdb.base/sigstep.exp: return from handleri; leave handler +FAIL: gdb.base/sigstep.exp: return from handleri; leave signal trampoline +FAIL: gdb.base/sigstep.exp: Set done as return will have skipped it +FAIL: gdb.base/sigstep.exp: set itimer = itimer_real +PASS: gdb.base/sigstep.exp: break 79 +FAIL: gdb.base/sigstep.exp: step to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler; break handler +FAIL: gdb.base/sigstep.exp: step to handler; performing step (the program is no longer running) +PASS: gdb.base/sigstep.exp: step to handler; clear handler +FAIL: gdb.base/sigstep.exp: next to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler; break handler +FAIL: gdb.base/sigstep.exp: next to handler; performing next (the program is no longer running) +PASS: gdb.base/sigstep.exp: next to handler; clear handler +FAIL: gdb.base/sigstep.exp: continue to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler; break handler +FAIL: gdb.base/sigstep.exp: continue to handler; performing continue (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue to handler; clear handler +FAIL: gdb.base/sigstep.exp: step to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler entry; break handler +FAIL: gdb.base/sigstep.exp: step to handler entry; performing step (the program is no longer running) +PASS: gdb.base/sigstep.exp: step to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: next to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler entry; break handler +FAIL: gdb.base/sigstep.exp: next to handler entry; performing next (the program is no longer running) +PASS: gdb.base/sigstep.exp: next to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: continue to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler entry; break handler +FAIL: gdb.base/sigstep.exp: continue to handler entry; performing continue (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: step over handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step over handler; advance to infinite loop +FAIL: gdb.base/sigstep.exp: step over handler; performing step (the program is no longer running) +FAIL: gdb.base/sigstep.exp: next over handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next over handler; advance to infinite loop +FAIL: gdb.base/sigstep.exp: next over handler; performing next (the program is no longer running) +FAIL: gdb.base/sigstep.exp: continue over handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue over handler; advance to infinite loop +FAIL: gdb.base/sigstep.exp: continue over handler; performing continue (the program is no longer running) +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break handler +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler; performing step (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear handler +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break handler +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler; performing next (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear handler +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break handler +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler; performing continue (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear handler +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break handler +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler entry; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: step on breakpoint, to handler entry; performing step (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break handler +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler entry; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: next on breakpoint, to handler entry; performing next (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break handler +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; performing continue (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear handler +FAIL: gdb.base/sigstep.exp: step on breakpoint, skip handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; break infinite loop +FAIL: gdb.base/sigstep.exp: step on breakpoint, skip handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: step on breakpoint, skip handler; performing step (the program is no longer running) +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; clear infinite loop +FAIL: gdb.base/sigstep.exp: next on breakpoint, skip handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; break infinite loop +FAIL: gdb.base/sigstep.exp: next on breakpoint, skip handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: next on breakpoint, skip handler; performing next (the program is no longer running) +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; clear infinite loop +FAIL: gdb.base/sigstep.exp: continue on breakpoint, skip handler; resync (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; break infinite loop +FAIL: gdb.base/sigstep.exp: continue on breakpoint, skip handler; continue to infinite loop (the program is no longer running) +FAIL: gdb.base/sigstep.exp: continue on breakpoint, skip handler; performing continue (the program is no longer running) +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; clear infinite loop +Running ./gdb.base/sizeof.exp ... +Running ./gdb.base/skip.exp ... +PASS: gdb.base/skip.exp: skip file (no default file) +PASS: gdb.base/skip.exp: skip function +PASS: gdb.base/skip.exp: skip (no default function) +PASS: gdb.base/skip.exp: info skip empty +PASS: gdb.base/skip.exp: skip file (skip.c) +PASS: gdb.base/skip.exp: skip (main) +PASS: gdb.base/skip.exp: skip file skip1.c +PASS: gdb.base/skip.exp: skip function baz +PASS: gdb.base/skip.exp: skip enable 999 +PASS: gdb.base/skip.exp: skip disable 999 +PASS: gdb.base/skip.exp: skip delete 999 +PASS: gdb.base/skip.exp: skip enable a +PASS: gdb.base/skip.exp: skip disable a +PASS: gdb.base/skip.exp: skip delete a +PASS: gdb.base/skip.exp: info skip 999 +PASS: gdb.base/skip.exp: info skip +PASS: gdb.base/skip.exp: step in the main +PASS: gdb.base/skip.exp: step after all ignored +PASS: gdb.base/skip.exp: skip delete 1 +PASS: gdb.base/skip.exp: info skip (delete 1) +PASS: gdb.base/skip.exp: step after deleting 1 (1) +PASS: gdb.base/skip.exp: step after deleting 1 (2) +PASS: gdb.base/skip.exp: step after deleting 1 (3) +PASS: gdb.base/skip.exp: skip disable 3 +PASS: gdb.base/skip.exp: info skip shows entry as disabled +FAIL: gdb.base/skip.exp: step after disabling 3 (1) +PASS: gdb.base/skip.exp: step after disabling 3 (2) +FAIL: gdb.base/skip.exp: step after disabling 3 (3) +PASS: gdb.base/skip.exp: step after disabling 3 (4) +PASS: gdb.base/skip.exp: step after disabling 3 (5) +PASS: gdb.base/skip.exp: skip enable 3 +PASS: gdb.base/skip.exp: info skip shows entry as enabled +PASS: gdb.base/skip.exp: step after enable 3 (1) +PASS: gdb.base/skip.exp: step after enable 3 (2) +PASS: gdb.base/skip.exp: step after enable 3 (3) +PASS: gdb.base/skip.exp: skip disable +PASS: gdb.base/skip.exp: info skip after disabling all +PASS: gdb.base/skip.exp: skip enable +PASS: gdb.base/skip.exp: info skip after enabling all +PASS: gdb.base/skip.exp: skip disable 4 2-3 +PASS: gdb.base/skip.exp: info skip after disabling 4 2-3 +PASS: gdb.base/skip.exp: skip enable 2-3 +PASS: gdb.base/skip.exp: info skip after enabling 2-3 +PASS: gdb.base/skip.exp: info skip 2-3 +PASS: gdb.base/skip.exp: skip delete 2 3 +PASS: gdb.base/skip.exp: info skip after deleting 2 3 +PASS: gdb.base/skip.exp: skip delete +PASS: gdb.base/skip.exp: info skip after deleting all +Running ./gdb.base/skip-solib.exp ... +Running ./gdb.base/so-impl-ld.exp ... +PASS: gdb.base/so-impl-ld.exp: step over solib call +FAIL: gdb.base/so-impl-ld.exp: step into solib call +FAIL: gdb.base/so-impl-ld.exp: step in solib call +FAIL: gdb.base/so-impl-ld.exp: step out of solib call +Running ./gdb.base/so-indr-cl.exp ... +Running ./gdb.base/solib-corrupted.exp ... +Running ./gdb.base/solib-disc.exp ... +PASS: gdb.base/solib-disc.exp: set stop-on-solib-events 1 +FAIL: gdb.base/solib-disc.exp: continue to load (the program exited) +FAIL: gdb.base/solib-disc.exp: save $pc after load +FAIL: gdb.base/solib-disc.exp: disconnect after load +FAIL: gdb.base/solib-disc.exp: reconnect after load +Running ./gdb.base/solib-display.exp ... +Running ./gdb.base/solib.exp ... +Running ./gdb.base/solib-nodir.exp ... +Running ./gdb.base/solib-overlap.exp ... +Running ./gdb.base/solib-symbol.exp ... +PASS: gdb.base/solib-symbol.exp: foo2 in main +FAIL: gdb.base/solib-symbol.exp: foo in libmd (got interactive prompt) +PASS: gdb.base/solib-symbol.exp: continue +FAIL: gdb.base/solib-symbol.exp: foo2 in mdlib +Running ./gdb.base/solib-weak.exp ... +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib1 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib2 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib1 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib2 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib1 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib2 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib1 first (the program exited) +FAIL: gdb.base/solib-weak.exp: setting breakpoint at bar +FAIL: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib2 first (the program exited) +Running ./gdb.base/source.exp ... +PASS: gdb.base/source.exp: script contains error +PASS: gdb.base/source.exp: source -v +PASS: gdb.base/source.exp: source after -v +PASS: gdb.base/source.exp: set search directories +PASS: gdb.base/source.exp: source -s +PASS: gdb.base/source.exp: source -s -v +PASS: gdb.base/source.exp: source -v -s +Running ./gdb.base/stack-checking.exp ... +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for small frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for medium frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for big frame +PASS: gdb.base/stack-checking.exp: bt +Running ./gdb.base/stale-infcall.exp ... +PASS: gdb.base/stale-infcall.exp: continue to breakpoint: test-next +PASS: gdb.base/stale-infcall.exp: set $test_fail_bpnum=$bpnum +XFAIL: gdb.base/stale-infcall.exp: test system longjmp tracking support +UNTESTED: gdb.base/stale-infcall.exp: System lacks support for tracking longjmps +Running ./gdb.base/stap-probe.exp ... +gdb compile failed, ./gdb.base/stap-probe.c:39:21: fatal error: sys/sdt.h: No such file or directory + #include <sys/sdt.h> + ^ +compilation terminated. +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +Running ./gdb.base/start.exp ... +UNTESTED: gdb.base/start.exp: start +Running ./gdb.base/step-break.exp ... +PASS: gdb.base/step-break.exp: breakpoint line number +PASS: gdb.base/step-break.exp: run until breakpoint set at a line number +PASS: gdb.base/step-break.exp: next 2 (1) +PASS: gdb.base/step-break.exp: next 2 (2) +PASS: gdb.base/step-break.exp: next 2 (3) +PASS: gdb.base/step-break.exp: next 2 (4) +PASS: gdb.base/step-break.exp: next 2 (5) +PASS: gdb.base/step-break.exp: next 2 (6) +Running ./gdb.base/step-bt.exp ... +PASS: gdb.base/step-bt.exp: breakpoint at first instruction of hello() +PASS: gdb.base/step-bt.exp: run to hello() +PASS: gdb.base/step-bt.exp: step first instruction +PASS: gdb.base/step-bt.exp: backtrace after first instruction step +PASS: gdb.base/step-bt.exp: step second instruction +PASS: gdb.base/step-bt.exp: backtrace after second instruction step +Running ./gdb.base/step-line.exp ... +PASS: gdb.base/step-line.exp: break f1 +PASS: gdb.base/step-line.exp: continue to f1 +PASS: gdb.base/step-line.exp: next over dummy 1 +PASS: gdb.base/step-line.exp: next to dummy 2 +PASS: gdb.base/step-line.exp: next over dummy 2 +PASS: gdb.base/step-line.exp: step into f2 +PASS: gdb.base/step-line.exp: next over dummy 4 +PASS: gdb.base/step-line.exp: next to dummy 5 +PASS: gdb.base/step-line.exp: next to dummy 6 +PASS: gdb.base/step-line.exp: next over dummy 6 +PASS: gdb.base/step-line.exp: next to dummy 7 +PASS: gdb.base/step-line.exp: next to dummy 8 +PASS: gdb.base/step-line.exp: next over dummy 8 +PASS: gdb.base/step-line.exp: next to dummy 9 +PASS: gdb.base/step-line.exp: next to dummy 10 +PASS: gdb.base/step-line.exp: next over dummy 10 +Running ./gdb.base/step-resume-infcall.exp ... +PASS: gdb.base/step-resume-infcall.exp: step +PASS: gdb.base/step-resume-infcall.exp: up +PASS: gdb.base/step-resume-infcall.exp: set $b=$pc +PASS: gdb.base/step-resume-infcall.exp: print $bpnum +PASS: gdb.base/step-resume-infcall.exp: disass/m +PASS: gdb.base/step-resume-infcall.exp: info breakpoints +PASS: gdb.base/step-resume-infcall.exp: next +PASS: gdb.base/step-resume-infcall.exp: p cond_hit +Running ./gdb.base/step-symless.exp ... +PASS: gdb.base/step-symless.exp: strip stub symbols +PASS: gdb.base/step-symless.exp: step +Running ./gdb.base/step-test.exp ... +PASS: gdb.base/step-test.exp: next 1 +PASS: gdb.base/step-test.exp: step 1 +PASS: gdb.base/step-test.exp: next 2 +PASS: gdb.base/step-test.exp: step 3 +PASS: gdb.base/step-test.exp: next 3 +PASS: gdb.base/step-test.exp: next over +PASS: gdb.base/step-test.exp: step into +PASS: gdb.base/step-test.exp: step out +PASS: gdb.base/step-test.exp: stepi to next line +PASS: gdb.base/step-test.exp: stepi into function +PASS: gdb.base/step-test.exp: stepi into function's first source line +PASS: gdb.base/step-test.exp: stepi: finish call +PASS: gdb.base/step-test.exp: nexti over function +PASS: gdb.base/step-test.exp: set breakpoint at call to large_struct_by_value +PASS: gdb.base/step-test.exp: run to pass large struct +PASS: gdb.base/step-test.exp: large struct by value +FAIL: gdb.base/step-test.exp: setting breakpoint at exit +Running ./gdb.base/store.exp ... +PASS: gdb.base/store.exp: tbreak wack_charest +PASS: gdb.base/store.exp: continue to wack_charest +PASS: gdb.base/store.exp: var charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: var charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: var charest l; setting l to 4 +PASS: gdb.base/store.exp: var charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: var charest l; next over add call +PASS: gdb.base/store.exp: var charest l; print incremented l, expecting 2 ..002. +PASS: gdb.base/store.exp: tbreak wack_short +PASS: gdb.base/store.exp: continue to wack_short +PASS: gdb.base/store.exp: var short l; print old l, expecting -1 +PASS: gdb.base/store.exp: var short l; print old r, expecting -2 +PASS: gdb.base/store.exp: var short l; setting l to 4 +PASS: gdb.base/store.exp: var short l; print new l, expecting 4 +PASS: gdb.base/store.exp: var short l; next over add call +FAIL: gdb.base/store.exp: var short l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_int +PASS: gdb.base/store.exp: continue to wack_int +PASS: gdb.base/store.exp: var int l; print old l, expecting -1 +PASS: gdb.base/store.exp: var int l; print old r, expecting -2 +PASS: gdb.base/store.exp: var int l; setting l to 4 +PASS: gdb.base/store.exp: var int l; print new l, expecting 4 +PASS: gdb.base/store.exp: var int l; next over add call +PASS: gdb.base/store.exp: var int l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_long +PASS: gdb.base/store.exp: continue to wack_long +PASS: gdb.base/store.exp: var long l; print old l, expecting -1 +PASS: gdb.base/store.exp: var long l; print old r, expecting -2 +PASS: gdb.base/store.exp: var long l; setting l to 4 +PASS: gdb.base/store.exp: var long l; print new l, expecting 4 +PASS: gdb.base/store.exp: var long l; next over add call +PASS: gdb.base/store.exp: var long l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_longest +PASS: gdb.base/store.exp: continue to wack_longest +PASS: gdb.base/store.exp: var longest l; print old l, expecting -1 +PASS: gdb.base/store.exp: var longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: var longest l; setting l to 4 +PASS: gdb.base/store.exp: var longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var longest l; next over add call +PASS: gdb.base/store.exp: var longest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_float +PASS: gdb.base/store.exp: continue to wack_float +PASS: gdb.base/store.exp: var float l; print old l, expecting -1 +PASS: gdb.base/store.exp: var float l; print old r, expecting -2 +PASS: gdb.base/store.exp: var float l; setting l to 4 +PASS: gdb.base/store.exp: var float l; print new l, expecting 4 +PASS: gdb.base/store.exp: var float l; next over add call +FAIL: gdb.base/store.exp: var float l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_double +PASS: gdb.base/store.exp: continue to wack_double +PASS: gdb.base/store.exp: var double l; print old l, expecting -1 +PASS: gdb.base/store.exp: var double l; print old r, expecting -2 +PASS: gdb.base/store.exp: var double l; setting l to 4 +PASS: gdb.base/store.exp: var double l; print new l, expecting 4 +PASS: gdb.base/store.exp: var double l; next over add call +FAIL: gdb.base/store.exp: var double l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_doublest +PASS: gdb.base/store.exp: continue to wack_doublest +PASS: gdb.base/store.exp: var doublest l; print old l, expecting -1 +PASS: gdb.base/store.exp: var doublest l; print old r, expecting -2 +PASS: gdb.base/store.exp: var doublest l; setting l to 4 +PASS: gdb.base/store.exp: var doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var doublest l; next over add call +FAIL: gdb.base/store.exp: var doublest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak add_charest +PASS: gdb.base/store.exp: continue to add_charest +PASS: gdb.base/store.exp: upvar charest l; up +PASS: gdb.base/store.exp: upvar charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: upvar charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: upvar charest l; set l to 4 +PASS: gdb.base/store.exp: upvar charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: tbreak add_short +PASS: gdb.base/store.exp: continue to add_short +PASS: gdb.base/store.exp: upvar short l; up +PASS: gdb.base/store.exp: upvar short l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar short l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar short l; set l to 4 +PASS: gdb.base/store.exp: upvar short l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_int +PASS: gdb.base/store.exp: continue to add_int +PASS: gdb.base/store.exp: upvar int l; up +PASS: gdb.base/store.exp: upvar int l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar int l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar int l; set l to 4 +PASS: gdb.base/store.exp: upvar int l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_long +PASS: gdb.base/store.exp: continue to add_long +PASS: gdb.base/store.exp: upvar long l; up +PASS: gdb.base/store.exp: upvar long l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar long l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar long l; set l to 4 +PASS: gdb.base/store.exp: upvar long l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_longest +PASS: gdb.base/store.exp: continue to add_longest +PASS: gdb.base/store.exp: upvar longest l; up +PASS: gdb.base/store.exp: upvar longest l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar longest l; set l to 4 +PASS: gdb.base/store.exp: upvar longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_float +PASS: gdb.base/store.exp: continue to add_float +PASS: gdb.base/store.exp: upvar float l; up +PASS: gdb.base/store.exp: upvar float l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar float l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar float l; set l to 4 +PASS: gdb.base/store.exp: upvar float l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_double +PASS: gdb.base/store.exp: continue to add_double +PASS: gdb.base/store.exp: upvar double l; up +PASS: gdb.base/store.exp: upvar double l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar double l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar double l; set l to 4 +PASS: gdb.base/store.exp: upvar double l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_doublest +PASS: gdb.base/store.exp: continue to add_doublest +PASS: gdb.base/store.exp: upvar doublest l; up +PASS: gdb.base/store.exp: upvar doublest l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar doublest l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar doublest l; set l to 4 +PASS: gdb.base/store.exp: upvar doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak wack_struct_1 +FAIL: gdb.base/store.exp: continue to wack_struct_1 +FAIL: gdb.base/store.exp: var struct 1 u; next to add_struct_1 call +PASS: gdb.base/store.exp: var struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: var struct 1 u; set u to s_1 +FAIL: gdb.base/store.exp: var struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak wack_struct_2 +FAIL: gdb.base/store.exp: continue to wack_struct_2 +FAIL: gdb.base/store.exp: var struct 2 u; next to add_struct_2 call +PASS: gdb.base/store.exp: var struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: var struct 2 u; set u to s_2 +FAIL: gdb.base/store.exp: var struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak wack_struct_3 +FAIL: gdb.base/store.exp: continue to wack_struct_3 +FAIL: gdb.base/store.exp: var struct 3 u; next to add_struct_3 call +PASS: gdb.base/store.exp: var struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: var struct 3 u; set u to s_3 +FAIL: gdb.base/store.exp: var struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak wack_struct_4 +FAIL: gdb.base/store.exp: continue to wack_struct_4 +FAIL: gdb.base/store.exp: var struct 4 u; next to add_struct_4 call +PASS: gdb.base/store.exp: var struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: var struct 4 u; set u to s_4 +FAIL: gdb.base/store.exp: var struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak add_struct_1 +PASS: gdb.base/store.exp: continue to add_struct_1 +PASS: gdb.base/store.exp: up struct 1 u; up +PASS: gdb.base/store.exp: up struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: up struct 1 u; set u to s_1 +PASS: gdb.base/store.exp: up struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak add_struct_2 +PASS: gdb.base/store.exp: continue to add_struct_2 +PASS: gdb.base/store.exp: up struct 2 u; up +PASS: gdb.base/store.exp: up struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: up struct 2 u; set u to s_2 +PASS: gdb.base/store.exp: up struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak add_struct_3 +PASS: gdb.base/store.exp: continue to add_struct_3 +PASS: gdb.base/store.exp: up struct 3 u; up +PASS: gdb.base/store.exp: up struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: up struct 3 u; set u to s_3 +PASS: gdb.base/store.exp: up struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak add_struct_4 +PASS: gdb.base/store.exp: continue to add_struct_4 +PASS: gdb.base/store.exp: up struct 4 u; up +PASS: gdb.base/store.exp: up struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: up struct 4 u; set u to s_4 +PASS: gdb.base/store.exp: up struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak wack_field_1 +PASS: gdb.base/store.exp: continue field 1 +PASS: gdb.base/store.exp: next field 1 +PASS: gdb.base/store.exp: old field 1 +PASS: gdb.base/store.exp: set variable u = F_1 +PASS: gdb.base/store.exp: new field 1 +PASS: gdb.base/store.exp: set variable u = F_1, u.i = f_1.i +PASS: gdb.base/store.exp: f_1.i +PASS: gdb.base/store.exp: set variable u = F_1, u.j = f_1.j +PASS: gdb.base/store.exp: f_1.j +PASS: gdb.base/store.exp: set variable u = F_1, u.k = f_1.k +PASS: gdb.base/store.exp: f_1.k +PASS: gdb.base/store.exp: set variable u = f_1, u.i = F_1.i +PASS: gdb.base/store.exp: F_1.i +PASS: gdb.base/store.exp: set variable u = f_1, u.j = F_1.j +PASS: gdb.base/store.exp: F_1.j +PASS: gdb.base/store.exp: set variable u = f_1, u.k = F_1.k +PASS: gdb.base/store.exp: F_1.k +PASS: gdb.base/store.exp: tbreak wack_field_2 +PASS: gdb.base/store.exp: continue field 2 +PASS: gdb.base/store.exp: next field 2 +PASS: gdb.base/store.exp: old field 2 +PASS: gdb.base/store.exp: set variable u = F_2 +PASS: gdb.base/store.exp: new field 2 +PASS: gdb.base/store.exp: set variable u = F_2, u.i = f_2.i +PASS: gdb.base/store.exp: f_2.i +PASS: gdb.base/store.exp: set variable u = F_2, u.j = f_2.j +PASS: gdb.base/store.exp: f_2.j +PASS: gdb.base/store.exp: set variable u = F_2, u.k = f_2.k +PASS: gdb.base/store.exp: f_2.k +PASS: gdb.base/store.exp: set variable u = f_2, u.i = F_2.i +PASS: gdb.base/store.exp: F_2.i +PASS: gdb.base/store.exp: set variable u = f_2, u.j = F_2.j +PASS: gdb.base/store.exp: F_2.j +PASS: gdb.base/store.exp: set variable u = f_2, u.k = F_2.k +PASS: gdb.base/store.exp: F_2.k +PASS: gdb.base/store.exp: tbreak wack_field_3 +PASS: gdb.base/store.exp: continue field 3 +PASS: gdb.base/store.exp: next field 3 +PASS: gdb.base/store.exp: old field 3 +PASS: gdb.base/store.exp: set variable u = F_3 +PASS: gdb.base/store.exp: new field 3 +PASS: gdb.base/store.exp: set variable u = F_3, u.i = f_3.i +PASS: gdb.base/store.exp: f_3.i +PASS: gdb.base/store.exp: set variable u = F_3, u.j = f_3.j +PASS: gdb.base/store.exp: f_3.j +PASS: gdb.base/store.exp: set variable u = F_3, u.k = f_3.k +PASS: gdb.base/store.exp: f_3.k +PASS: gdb.base/store.exp: set variable u = f_3, u.i = F_3.i +PASS: gdb.base/store.exp: F_3.i +PASS: gdb.base/store.exp: set variable u = f_3, u.j = F_3.j +PASS: gdb.base/store.exp: F_3.j +PASS: gdb.base/store.exp: set variable u = f_3, u.k = F_3.k +PASS: gdb.base/store.exp: F_3.k +PASS: gdb.base/store.exp: tbreak wack_field_4 +PASS: gdb.base/store.exp: continue field 4 +PASS: gdb.base/store.exp: next field 4 +PASS: gdb.base/store.exp: old field 4 +PASS: gdb.base/store.exp: set variable u = F_4 +PASS: gdb.base/store.exp: new field 4 +PASS: gdb.base/store.exp: set variable u = F_4, u.i = f_4.i +PASS: gdb.base/store.exp: f_4.i +PASS: gdb.base/store.exp: set variable u = F_4, u.j = f_4.j +PASS: gdb.base/store.exp: f_4.j +PASS: gdb.base/store.exp: set variable u = F_4, u.k = f_4.k +PASS: gdb.base/store.exp: f_4.k +PASS: gdb.base/store.exp: set variable u = f_4, u.i = F_4.i +PASS: gdb.base/store.exp: F_4.i +PASS: gdb.base/store.exp: set variable u = f_4, u.j = F_4.j +PASS: gdb.base/store.exp: F_4.j +PASS: gdb.base/store.exp: set variable u = f_4, u.k = F_4.k +PASS: gdb.base/store.exp: F_4.k +Running ./gdb.base/structs2.exp ... +PASS: gdb.base/structs2.exp: set width 0 +FAIL: gdb.base/structs2.exp: structs2 sanity check +PASS: gdb.base/structs2.exp: structs2 breakpoint set +FAIL: gdb.base/structs2.exp: structs2 continue1 +FAIL: gdb.base/structs2.exp: structs2 continue2 +Running ./gdb.base/structs3.exp ... +PASS: gdb.base/structs3.exp: print two +PASS: gdb.base/structs3.exp: print *twop +PASS: gdb.base/structs3.exp: print *(struct Two *)onep +PASS: gdb.base/structs3.exp: print *(tTwo *)onep +Running ./gdb.base/structs.exp ... +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: continue to breakpoint: chartest-done +PASS: gdb.base/structs.exp: p chartest +PASS: gdb.base/structs.exp: ptype foo1; structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 9 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 9 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 9 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 10 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 10 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 10 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 11 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 11 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 11 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 12 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 12 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 12 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 13 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 13 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 13 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 14 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 14 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 14 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 15 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 15 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 15 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 16 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 16 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 16 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 17 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 17 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 17 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 5 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 6 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 7 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 8 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 8 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 8 structs-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tll +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tf +FAIL: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf +FAIL: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-td +FAIL: gdb.base/structs.exp: value foo<n> returned; return 1 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tld +FAIL: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tld +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tld +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tll-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tld-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-td-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-td +Running ./gdb.base/subst.exp ... +PASS: gdb.base/subst.exp: deactivate GDB's confirmation interface +PASS: gdb.base/subst.exp: show substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path, too many arguments +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too few arguments +PASS: gdb.base/subst.exp: set substitute-path, first argument is empty string +PASS: gdb.base/subst.exp: add from -> to substitution rule +PASS: gdb.base/subst.exp: add from1 -> to1 substitution rule +PASS: gdb.base/subst.exp: add source -> destination substitution rule +PASS: gdb.base/subst.exp: add depuis -> vers substitution rule +PASS: gdb.base/subst.exp: add substitution rule to empty string +PASS: gdb.base/subst.exp: show substitute-path after all paths added +PASS: gdb.base/subst.exp: show substitute-path from, after all paths added +PASS: gdb.base/subst.exp: show substitute-path depuis, after all paths added +PASS: gdb.base/subst.exp: show substitute-path garbage, after all paths added +PASS: gdb.base/subst.exp: unset substitute-path from +PASS: gdb.base/subst.exp: show substitute-path from, after unsetting it +PASS: gdb.base/subst.exp: show substitute-path after from rule removed +PASS: gdb.base/subst.exp: unset substitute-path from after the rule was removed +PASS: gdb.base/subst.exp: unset substitute-path depuis (middle of list) +PASS: gdb.base/subst.exp: show substitute-path after depuis rule removed +PASS: gdb.base/subst.exp: unset substitute-path empty (end of list) +PASS: gdb.base/subst.exp: show substitute-path after empty rule removed +PASS: gdb.base/subst.exp: remove all remaining substitution rules +PASS: gdb.base/subst.exp: show substitute-path after all remaining rules removed +Running ./gdb.base/symbol-without-target_section.exp ... +PASS: gdb.base/symbol-without-target_section.exp: add-symbol-file +PASS: gdb.base/symbol-without-target_section.exp: list main +PASS: gdb.base/symbol-without-target_section.exp: print symbol_without_target_section +Running ./gdb.base/term.exp ... +Running ./gdb.base/testenv.exp ... +Running ./gdb.base/trace-commands.exp ... +PASS: gdb.base/trace-commands.exp: show trace-commands says off +PASS: gdb.base/trace-commands.exp: source -v +PASS: gdb.base/trace-commands.exp: set trace-commands +PASS: gdb.base/trace-commands.exp: show trace-commands says on +PASS: gdb.base/trace-commands.exp: simple trace-commands test +PASS: gdb.base/trace-commands.exp: nested trace-commands test +PASS: gdb.base/trace-commands.exp: define user command +PASS: gdb.base/trace-commands.exp: nested trace-commands test with source +PASS: gdb.base/trace-commands.exp: depth resets on error part 1 +PASS: gdb.base/trace-commands.exp: depth resets on error part 2 +Running ./gdb.base/tui-layout.exp ... +PASS: gdb.base/tui-layout.exp: layout asm +Running ./gdb.base/twice.exp ... +PASS: gdb.base/twice.exp: step +Running ./gdb.base/type-opaque.exp ... +FAIL: gdb.base/type-opaque.exp: opaque struct type resolving +PASS: gdb.base/type-opaque.exp: empty struct type resolving +PASS: gdb.base/type-opaque.exp: filled struct type resolving +FAIL: gdb.base/type-opaque.exp: opaque union type resolving +PASS: gdb.base/type-opaque.exp: empty union type resolving +PASS: gdb.base/type-opaque.exp: filled union type resolving +Running ./gdb.base/ui-redirect.exp ... +PASS: gdb.base/ui-redirect.exp: commands +PASS: gdb.base/ui-redirect.exp: print 1 +PASS: gdb.base/ui-redirect.exp: end +PASS: gdb.base/ui-redirect.exp: set logging file /dev/null +PASS: gdb.base/ui-redirect.exp: set logging on +PASS: gdb.base/ui-redirect.exp: save breakpoints /dev/null +PASS: gdb.base/ui-redirect.exp: set logging off +PASS: gdb.base/ui-redirect.exp: help +Running ./gdb.base/unload.exp ... +PASS: gdb.base/unload.exp: pending breakpoint info before run +FAIL: gdb.base/unload.exp: running program (the program exited) +FAIL: gdb.base/unload.exp: pending breakpoint info on first run at shrfunc1 +FAIL: gdb.base/unload.exp: continuing to unloaded libfile (the program is no longer running) +FAIL: gdb.base/unload.exp: print y from libfile +FAIL: gdb.base/unload.exp: rerun to shared library breakpoint +FAIL: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc1 +FAIL: gdb.base/unload.exp: continuing to unloaded libfile (the program exited) +FAIL: gdb.base/unload.exp: continue to shrfunc2 (the program is no longer running) +FAIL: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc2 +FAIL: gdb.base/unload.exp: continuing to unloaded libfile2 (the program is no longer running) +FAIL: gdb.base/unload.exp: print y from libfile2 +Running ./gdb.base/until.exp ... +PASS: gdb.base/until.exp: until line number +PASS: gdb.base/until.exp: malformed until +PASS: gdb.base/until.exp: until factorial, recursive function +PASS: gdb.base/until.exp: until func, not called by current frame +Running ./gdb.base/unwindonsignal.exp ... +Running ./gdb.base/valgrind-db-attach.exp ... +Running ./gdb.base/valgrind-infcall.exp ... +Running ./gdb.base/value-double-free.exp ... +FAIL: gdb.base/value-double-free.exp: watch var +PASS: gdb.base/value-double-free.exp: continue +PASS: gdb.base/value-double-free.exp: print empty() +PASS: gdb.base/value-double-free.exp: help help +Running ./gdb.base/varargs.exp ... +PASS: gdb.base/varargs.exp: set print sevenbit-strings +PASS: gdb.base/varargs.exp: set print address off +PASS: gdb.base/varargs.exp: set width 0 +Running ./gdb.base/volatile.exp ... +PASS: gdb.base/volatile.exp: continue to marker1 +PASS: gdb.base/volatile.exp: up from marker1 +PASS: gdb.base/volatile.exp: ptype vox +PASS: gdb.base/volatile.exp: ptype victuals +PASS: gdb.base/volatile.exp: ptype vixen +PASS: gdb.base/volatile.exp: ptype vitriol +PASS: gdb.base/volatile.exp: ptype vellum +PASS: gdb.base/volatile.exp: ptype valve +PASS: gdb.base/volatile.exp: ptype vacuity +PASS: gdb.base/volatile.exp: ptype vertigo +PASS: gdb.base/volatile.exp: ptype vampire +PASS: gdb.base/volatile.exp: ptype viper +PASS: gdb.base/volatile.exp: ptype vigour +PASS: gdb.base/volatile.exp: ptype vapour +PASS: gdb.base/volatile.exp: ptype ventricle +PASS: gdb.base/volatile.exp: ptype vigintillion +PASS: gdb.base/volatile.exp: ptype vocation +PASS: gdb.base/volatile.exp: ptype veracity +PASS: gdb.base/volatile.exp: ptype vapidity +PASS: gdb.base/volatile.exp: ptype velocity +PASS: gdb.base/volatile.exp: ptype veneer +PASS: gdb.base/volatile.exp: ptype video +PASS: gdb.base/volatile.exp: ptype vacuum +PASS: gdb.base/volatile.exp: ptype veniality +PASS: gdb.base/volatile.exp: ptype vitality +PASS: gdb.base/volatile.exp: ptype voracity +PASS: gdb.base/volatile.exp: ptype victor +PASS: gdb.base/volatile.exp: ptype vicar +PASS: gdb.base/volatile.exp: ptype victory +PASS: gdb.base/volatile.exp: ptype vicarage +PASS: gdb.base/volatile.exp: ptype vein +PASS: gdb.base/volatile.exp: ptype vogue +PASS: gdb.base/volatile.exp: ptype cavern +PASS: gdb.base/volatile.exp: ptype coverlet +PASS: gdb.base/volatile.exp: ptype caveat +PASS: gdb.base/volatile.exp: ptype covenant +PASS: gdb.base/volatile.exp: ptype vizier +PASS: gdb.base/volatile.exp: ptype vanadium +PASS: gdb.base/volatile.exp: ptype vane +PASS: gdb.base/volatile.exp: ptype veldt +PASS: gdb.base/volatile.exp: ptype cove +PASS: gdb.base/volatile.exp: ptype cavity +PASS: gdb.base/volatile.exp: ptype vagus +PASS: gdb.base/volatile.exp: ptype vagrancy +PASS: gdb.base/volatile.exp: ptype vagary +PASS: gdb.base/volatile.exp: ptype vendor +PASS: gdb.base/volatile.exp: ptype qux2 +Running ./gdb.base/watch-cond.exp ... +PASS: gdb.base/watch-cond.exp: set write watchpoint on global variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with global expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on local variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with local expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on global2 variable +PASS: gdb.base/watch-cond.exp: watchpoint on global2 variable triggers +PASS: gdb.base/watch-cond.exp: condition of watchpoint 2 changes +PASS: gdb.base/watch-cond.exp: watchpoint stops with untestable local expression +Running ./gdb.base/watch-cond-infcall.exp ... +PASS: gdb.base/watch-cond-infcall.exp: sw: watch var if return_1 () +PASS: gdb.base/watch-cond-infcall.exp: sw: continue +Running ./gdb.base/watch-non-mem.exp ... +PASS: gdb.base/watch-non-mem.exp: set write watchpoint on $pc +PASS: gdb.base/watch-non-mem.exp: watchpoint on $pc works +Running ./gdb.base/watchpoint-cond-gone.exp ... +PASS: gdb.base/watchpoint-cond-gone.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-cond-gone.exp: continue to breakpoint: Place to set the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Place the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Catch the no longer valid watchpoint +Running ./gdb.base/watchpoint-delete.exp ... +PASS: gdb.base/watchpoint-delete.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-delete.exp: continue to breakpoint: break-here +PASS: gdb.base/watchpoint-delete.exp: watch x +PASS: gdb.base/watchpoint-delete.exp: delete $bpnum +Running ./gdb.base/watchpoint.exp ... +PASS: gdb.base/watchpoint.exp: disable fast watches +PASS: gdb.base/watchpoint.exp: show disable fast watches +PASS: gdb.base/watchpoint.exp: set slow conditional watch +PASS: gdb.base/watchpoint.exp: trigger slow conditional watch +PASS: gdb.base/watchpoint.exp: delete watch ival3 +PASS: gdb.base/watchpoint.exp: set slow condition watch w/thread +PASS: gdb.base/watchpoint.exp: delete watch w/condition and thread +PASS: gdb.base/watchpoint.exp: rwatch disallowed when can-set-hw-watchpoints cleared +PASS: gdb.base/watchpoint.exp: set breakpoint at marker1 +PASS: gdb.base/watchpoint.exp: set breakpoint at marker2 +PASS: gdb.base/watchpoint.exp: info break in watchpoint.exp +PASS: gdb.base/watchpoint.exp: set watchpoint on ival3 +PASS: gdb.base/watchpoint.exp: watchpoint found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: run to marker1 in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: enable watchpoint +PASS: gdb.base/watchpoint.exp: break func1 +PASS: gdb.base/watchpoint.exp: set $func1_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: continue to breakpoint at func1 +PASS: gdb.base/watchpoint.exp: watchpoint hit, first time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoint.exp: delete $func1_breakpoint_number +PASS: gdb.base/watchpoint.exp: watchpoint hit, second time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoint.exp: watchpoint hit, third time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 5 +PASS: gdb.base/watchpoint.exp: continue to marker2 +PASS: gdb.base/watchpoint.exp: watchpoint disabled +FAIL: gdb.base/watchpoint.exp: setting breakpoint at exit +PASS: gdb.base/watchpoint.exp: watchpoints found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: run to marker1 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint enabled +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, first time +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, second time +PASS: gdb.base/watchpoint.exp: disable watchpoint #2 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint disabled in table +PASS: gdb.base/watchpoint.exp: disabled watchpoint skipped +FAIL: gdb.base/watchpoint.exp: setting breakpoint at exit +PASS: gdb.base/watchpoint.exp: watch ival2 +PASS: gdb.base/watchpoint.exp: break func2 if 0 +PASS: gdb.base/watchpoint.exp: p $func2_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: calling function with watchpoint enabled +PASS: gdb.base/watchpoint.exp: finish from marker1 +PASS: gdb.base/watchpoint.exp: back at main from marker1 +PASS: gdb.base/watchpoint.exp: next to `for' in watchpoint.exp +PASS: gdb.base/watchpoint.exp: until to ival1 assignment +PASS: gdb.base/watchpoint.exp: until to ival3 assignment +PASS: gdb.base/watchpoint.exp: until out of loop +PASS: gdb.base/watchpoint.exp: step to ival2 assignment +PASS: gdb.base/watchpoint.exp: watch ptr1->val +PASS: gdb.base/watchpoint.exp: break marker5 +PASS: gdb.base/watchpoint.exp: Test complex watchpoint +PASS: gdb.base/watchpoint.exp: did not trigger wrong watchpoint +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: break marker6 +PASS: gdb.base/watchpoint.exp: continue to marker6 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set local watch +PASS: gdb.base/watchpoint.exp: trigger local watch +PASS: gdb.base/watchpoint.exp: self-delete local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set partially local watch +PASS: gdb.base/watchpoint.exp: trigger1 partially local watch +PASS: gdb.base/watchpoint.exp: trigger2 partially local watch +PASS: gdb.base/watchpoint.exp: self-delete partially local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set static local watch +PASS: gdb.base/watchpoint.exp: trigger static local watch +PASS: gdb.base/watchpoint.exp: continue after trigger static local watch +PASS: gdb.base/watchpoint.exp: static local watch did not self-delete +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call +PASS: gdb.base/watchpoint.exp: trigger local watch in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch in recursive call +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call with explicit scope +PASS: gdb.base/watchpoint.exp: trigger local watch with explicit scope in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch with explicit scope in recursive call (2) +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +FAIL: gdb.base/watchpoint.exp: setting breakpoint at exit +PASS: gdb.base/watchpoint.exp: watchpoint refused to insert on nonexistent struct member +PASS: gdb.base/watchpoint.exp: watch global_ptr +PASS: gdb.base/watchpoint.exp: watch *(int *) 0 +PASS: gdb.base/watchpoint.exp: watch -location *global_ptr +PASS: gdb.base/watchpoint.exp: watch *global_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_breakpoint_number = $bpnum +FAIL: gdb.base/watchpoint.exp: global_ptr next +FAIL: gdb.base/watchpoint.exp: next over ptr init +FAIL: gdb.base/watchpoint.exp: next over buffer set +PASS: gdb.base/watchpoint.exp: delete $global_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: watch **global_ptr_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_ptr_breakpoint_number = $bpnum +FAIL: gdb.base/watchpoint.exp: global_ptr_ptr next +FAIL: gdb.base/watchpoint.exp: next over global_ptr_ptr init +FAIL: gdb.base/watchpoint.exp: next over global_ptr_ptr buffer set +FAIL: gdb.base/watchpoint.exp: next over global_ptr_ptr pointer advance +PASS: gdb.base/watchpoint.exp: delete $global_ptr_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: continue to breakpoint: second x assignment +PASS: gdb.base/watchpoint.exp: watch x +PASS: gdb.base/watchpoint.exp: next after watch x +PASS: gdb.base/watchpoint.exp: delete watch x +PASS: gdb.base/watchpoint.exp: watch buf +PASS: gdb.base/watchpoint.exp: watchpoint on buf hit +PASS: gdb.base/watchpoint.exp: delete watch buf +PASS: gdb.base/watchpoint.exp: number is constant +PASS: gdb.base/watchpoint.exp: number with cast is constant +PASS: gdb.base/watchpoint.exp: marker1 is constant +PASS: gdb.base/watchpoint.exp: watch count + 6 +PASS: gdb.base/watchpoint.exp: delete watchpoint `count + 6' +PASS: gdb.base/watchpoint.exp: watch 7 + count +PASS: gdb.base/watchpoint.exp: delete watchpoint `7 + count' +PASS: gdb.base/watchpoint.exp: watch $pc +PASS: gdb.base/watchpoint.exp: disable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: reenable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: watchpoint `$pc' is enabled +PASS: gdb.base/watchpoint.exp: delete watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func5 breakpoint here +PASS: gdb.base/watchpoint.exp: watch -location .x +PASS: gdb.base/watchpoint.exp: continue with watch -location +PASS: gdb.base/watchpoint.exp: delete watch -location +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func6 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo2 +PASS: gdb.base/watchpoint.exp: continue with watch foo2 +PASS: gdb.base/watchpoint.exp: delete watch foo2 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func7 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo4 +PASS: gdb.base/watchpoint.exp: continue with watch foo4 +PASS: gdb.base/watchpoint.exp: delete watch foo4 +Running ./gdb.base/watchpoint-hw.exp ... +Running ./gdb.base/watchpoint-hw-hit-once.exp ... +Running ./gdb.base/watchpoints.exp ... +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 5 +Running ./gdb.base/watchpoint-solib.exp ... +PASS: gdb.base/watchpoint-solib.exp: set pending breakpoint +FAIL: gdb.base/watchpoint-solib.exp: continue to foo (the program exited) +FAIL: gdb.base/watchpoint-solib.exp: set watchpoint on g +FAIL: gdb.base/watchpoint-solib.exp: continue to watchpoint hit (the program is no longer running) +PASS: gdb.base/watchpoint-solib.exp: rerun to main +FAIL: gdb.base/watchpoint-solib.exp: continue to foo again (the program exited) +FAIL: gdb.base/watchpoint-solib.exp: continue to watchpoint hit again (the program is no longer running) +Running ./gdb.base/watch-read.exp ... +Running ./gdb.base/watch_thread_num.exp ... +Running ./gdb.base/watch-vfork.exp ... +Running ./gdb.base/wchar.exp ... +PASS: gdb.base/wchar.exp: print narrow +PASS: gdb.base/wchar.exp: print single +PASS: gdb.base/wchar.exp: print simple +PASS: gdb.base/wchar.exp: print difficile +PASS: gdb.base/wchar.exp: print simple[2] +PASS: gdb.base/wchar.exp: print difficile[2] +PASS: gdb.base/wchar.exp: print repeat +PASS: gdb.base/wchar.exp: print repeat_p +PASS: gdb.base/wchar.exp: set print null on +PASS: gdb.base/wchar.exp: print repeat (print null on) +PASS: gdb.base/wchar.exp: set print elements 3 +PASS: gdb.base/wchar.exp: print repeat (print elements 3) +PASS: gdb.base/wchar.exp: print repeat_p (print elements 3) +Running ./gdb.base/whatis.exp ... +PASS: gdb.base/whatis.exp: whatis char +PASS: gdb.base/whatis.exp: whatis signed char +PASS: gdb.base/whatis.exp: whatis unsigned char +PASS: gdb.base/whatis.exp: whatis short +PASS: gdb.base/whatis.exp: whatis signed short +PASS: gdb.base/whatis.exp: whatis unsigned short +PASS: gdb.base/whatis.exp: whatis int +PASS: gdb.base/whatis.exp: whatis signed int +PASS: gdb.base/whatis.exp: whatis unsigned int +PASS: gdb.base/whatis.exp: whatis long +PASS: gdb.base/whatis.exp: whatis signed long +PASS: gdb.base/whatis.exp: whatis unsigned long +PASS: gdb.base/whatis.exp: whatis unsigned long long +PASS: gdb.base/whatis.exp: whatis float +PASS: gdb.base/whatis.exp: whatis double +PASS: gdb.base/whatis.exp: whatis char array +PASS: gdb.base/whatis.exp: whatis signed char array +PASS: gdb.base/whatis.exp: whatis unsigned char array +PASS: gdb.base/whatis.exp: whatis short array +PASS: gdb.base/whatis.exp: whatis signed short array +PASS: gdb.base/whatis.exp: whatis unsigned short array +PASS: gdb.base/whatis.exp: whatis int array +PASS: gdb.base/whatis.exp: whatis signed int array +PASS: gdb.base/whatis.exp: whatis unsigned int array +PASS: gdb.base/whatis.exp: whatis long array +PASS: gdb.base/whatis.exp: whatis signed long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis float array +PASS: gdb.base/whatis.exp: whatis double array +PASS: gdb.base/whatis.exp: whatis char pointer +PASS: gdb.base/whatis.exp: whatis signed char pointer +PASS: gdb.base/whatis.exp: whatis unsigned char pointer +PASS: gdb.base/whatis.exp: whatis short pointer +PASS: gdb.base/whatis.exp: whatis signed short pointer +PASS: gdb.base/whatis.exp: whatis unsigned short pointer +PASS: gdb.base/whatis.exp: whatis int pointer +PASS: gdb.base/whatis.exp: whatis signed int pointer +PASS: gdb.base/whatis.exp: whatis unsigned int pointer +PASS: gdb.base/whatis.exp: whatis long pointer +PASS: gdb.base/whatis.exp: whatis signed long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long pointer +PASS: gdb.base/whatis.exp: whatis long long pointer +PASS: gdb.base/whatis.exp: whatis signed long long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long long pointer +PASS: gdb.base/whatis.exp: whatis float pointer +PASS: gdb.base/whatis.exp: whatis double pointer +PASS: gdb.base/whatis.exp: whatis named structure +PASS: gdb.base/whatis.exp: whatis named structure using type name +PASS: gdb.base/whatis.exp: whatis unnamed structure +PASS: gdb.base/whatis.exp: whatis named union +PASS: gdb.base/whatis.exp: whatis named union using type name +PASS: gdb.base/whatis.exp: whatis unnamed union +PASS: gdb.base/whatis.exp: whatis char function +PASS: gdb.base/whatis.exp: whatis signed char function +PASS: gdb.base/whatis.exp: whatis unsigned char function +PASS: gdb.base/whatis.exp: whatis short function +PASS: gdb.base/whatis.exp: whatis signed short function +PASS: gdb.base/whatis.exp: whatis unsigned short function +PASS: gdb.base/whatis.exp: whatis int function +PASS: gdb.base/whatis.exp: whatis signed int function +PASS: gdb.base/whatis.exp: whatis unsigned int function +PASS: gdb.base/whatis.exp: whatis long function +PASS: gdb.base/whatis.exp: whatis signed long function +PASS: gdb.base/whatis.exp: whatis unsigned long function +PASS: gdb.base/whatis.exp: whatis long long function +PASS: gdb.base/whatis.exp: whatis signed long long function +PASS: gdb.base/whatis.exp: whatis unsigned long long function +PASS: gdb.base/whatis.exp: whatis float function +PASS: gdb.base/whatis.exp: whatis double function +PASS: gdb.base/whatis.exp: whatis complicated structure +PASS: gdb.base/whatis.exp: whatis complicated union +PASS: gdb.base/whatis.exp: whatis enumeration +PASS: gdb.base/whatis.exp: whatis enumeration using type name +PASS: gdb.base/whatis.exp: whatis outer structure +PASS: gdb.base/whatis.exp: whatis outer structure member +PASS: gdb.base/whatis.exp: whatis inner structure +PASS: gdb.base/whatis.exp: whatis inner structure member +PASS: gdb.base/whatis.exp: whatis inner union +PASS: gdb.base/whatis.exp: whatis inner union member +PASS: gdb.base/whatis.exp: whatis using typedef type name +PASS: gdb.base/whatis.exp: whatis applied to variable defined by typedef +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to const pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to const pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to array +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking int,int and returning int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking const int ptr and varargs and returning int +PASS: gdb.base/whatis.exp: whatis applied to function with types trailing 'void' +PASS: gdb.base/whatis.exp: whatis applied to function with 'void' parameter type +Running ./gdb.base/whatis-exp.exp ... +PASS: gdb.base/whatis-exp.exp: set variable x=14 +PASS: gdb.base/whatis-exp.exp: set variable y=2 +PASS: gdb.base/whatis-exp.exp: set variable z=2 +PASS: gdb.base/whatis-exp.exp: set variable w=3 +PASS: gdb.base/whatis-exp.exp: print value of x +PASS: gdb.base/whatis-exp.exp: print value of y +PASS: gdb.base/whatis-exp.exp: print value of z +PASS: gdb.base/whatis-exp.exp: print value of w +PASS: gdb.base/whatis-exp.exp: whatis value of x+y +PASS: gdb.base/whatis-exp.exp: whatis value of x-y +PASS: gdb.base/whatis-exp.exp: whatis value of x*y +PASS: gdb.base/whatis-exp.exp: whatis value of x/y +PASS: gdb.base/whatis-exp.exp: whatis value of x%y +PASS: gdb.base/whatis-exp.exp: whatis value of x=y +PASS: gdb.base/whatis-exp.exp: whatis value of x+=2 +PASS: gdb.base/whatis-exp.exp: whatis value of ++x +PASS: gdb.base/whatis-exp.exp: whatis value of --x +PASS: gdb.base/whatis-exp.exp: whatis value of x++ +PASS: gdb.base/whatis-exp.exp: whatis value of x-- +Running ./gdb.btrace/enable.exp ... +Running ./gdb.btrace/function_call_history.exp ... +Running ./gdb.btrace/instruction_history.exp ... +Running ./gdb.cell/arch.exp ... +Running ./gdb.cell/break.exp ... +Running ./gdb.cell/bt.exp ... +Running ./gdb.cell/core.exp ... +Running ./gdb.cell/data.exp ... +Running ./gdb.cell/dwarfaddr.exp ... +Running ./gdb.cell/ea-cache.exp ... +Running ./gdb.cell/ea-standalone.exp ... +Running ./gdb.cell/ea-test.exp ... +Running ./gdb.cell/fork.exp ... +Running ./gdb.cell/f-regs.exp ... +Running ./gdb.cell/gcore.exp ... +Running ./gdb.cell/mem-access.exp ... +Running ./gdb.cell/ptype.exp ... +Running ./gdb.cell/registers.exp ... +Running ./gdb.cell/sizeof.exp ... +Running ./gdb.cell/solib.exp ... +Running ./gdb.cell/solib-symbol.exp ... +Running ./gdb.cp/abstract-origin.exp ... +PASS: gdb.cp/abstract-origin.exp: continue to breakpoint: break-here +PASS: gdb.cp/abstract-origin.exp: p problem +Running ./gdb.cp/ambiguous.exp ... +Running ./gdb.cp/annota2.exp ... +Running ./gdb.cp/annota3.exp ... +Running ./gdb.cp/anon-ns.exp ... +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +Running ./gdb.cp/anon-struct.exp ... +FAIL: gdb.cp/anon-struct.exp: print type of t::t +PASS: gdb.cp/anon-struct.exp: print type of X::t2 +FAIL: gdb.cp/anon-struct.exp: print type of X::t2::t2 +FAIL: gdb.cp/anon-struct.exp: print type of t3::~t3 +Running ./gdb.cp/anon-union.exp ... +PASS: gdb.cp/anon-union.exp: set width 0 +PASS: gdb.cp/anon-union.exp: next 1 +PASS: gdb.cp/anon-union.exp: print foo 1 +PASS: gdb.cp/anon-union.exp: next 2 +PASS: gdb.cp/anon-union.exp: print foo 2 +PASS: gdb.cp/anon-union.exp: set var foo.cloth +PASS: gdb.cp/anon-union.exp: print foo 3 +PASS: gdb.cp/anon-union.exp: next 3 +PASS: gdb.cp/anon-union.exp: print foo 4 +PASS: gdb.cp/anon-union.exp: set var foo.pebble +PASS: gdb.cp/anon-union.exp: print foo 5 +PASS: gdb.cp/anon-union.exp: set var foo.qux +PASS: gdb.cp/anon-union.exp: print foo 6 +PASS: gdb.cp/anon-union.exp: set var foo.mux +PASS: gdb.cp/anon-union.exp: print foo 7 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock +PASS: gdb.cp/anon-union.exp: print foo 8 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock2 +PASS: gdb.cp/anon-union.exp: print foo 9 +PASS: gdb.cp/anon-union.exp: next 4 +PASS: gdb.cp/anon-union.exp: print w 1 +PASS: gdb.cp/anon-union.exp: print z 1 +PASS: gdb.cp/anon-union.exp: next 5 +PASS: gdb.cp/anon-union.exp: print w 2 +PASS: gdb.cp/anon-union.exp: print z 2 +PASS: gdb.cp/anon-union.exp: set var z +PASS: gdb.cp/anon-union.exp: print w 3 +PASS: gdb.cp/anon-union.exp: print z 3 +Running ./gdb.cp/arg-reference.exp ... +PASS: gdb.cp/arg-reference.exp: No false reference +Running ./gdb.cp/baseenum.exp ... +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 1 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 2 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A in namespace N +Running ./gdb.cp/bool.exp ... +PASS: gdb.cp/bool.exp: print return_true() +PASS: gdb.cp/bool.exp: print return_false() +Running ./gdb.cp/breakpoint.exp ... +PASS: gdb.cp/breakpoint.exp: continue to C1::Nested::foo +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method 2 +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +Running ./gdb.cp/bs15503.exp ... +PASS: gdb.cp/bs15503.exp: break StringTest<wchar_t>::testFunction +PASS: gdb.cp/bs15503.exp: continue to StringTest<wchar_t> +PASS: gdb.cp/bs15503.exp: continue to breakpoint: find position where blank needs to be inserted +FAIL: gdb.cp/bs15503.exp: print s.length() +FAIL: gdb.cp/bs15503.exp: print s[0] +FAIL: gdb.cp/bs15503.exp: print s[s.length()-1] +PASS: gdb.cp/bs15503.exp: print (const char *) s +FAIL: gdb.cp/bs15503.exp: print (const char *) s.substr(0,4) +FAIL: gdb.cp/bs15503.exp: print (const char *) (s=s.substr(0,4)) +Running ./gdb.cp/call-c.exp ... +PASS: gdb.cp/call-c.exp: b 43 +PASS: gdb.cp/call-c.exp: print foo(1) +PASS: gdb.cp/call-c.exp: continue to bp +PASS: gdb.cp/call-c.exp: print rf->func() +PASS: gdb.cp/call-c.exp: print handle->func() +Running ./gdb.cp/casts.exp ... +PASS: gdb.cp/casts.exp: cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: let compiler cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: cast derived class pointer to base class pointer +PASS: gdb.cp/casts.exp: cast derived class reference to base class reference +PASS: gdb.cp/casts.exp: cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: let compiler cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: basic test of const_cast +PASS: gdb.cp/casts.exp: const_cast of 0 +PASS: gdb.cp/casts.exp: basic test of static_cast +PASS: gdb.cp/casts.exp: static_cast to reference type +PASS: gdb.cp/casts.exp: basic test of reinterpret_cast +PASS: gdb.cp/casts.exp: test invalid reinterpret_cast +PASS: gdb.cp/casts.exp: reinterpret_cast to reference type +PASS: gdb.cp/casts.exp: whatis decltype(5) +PASS: gdb.cp/casts.exp: old-style cast using __typeof__ +PASS: gdb.cp/casts.exp: static_cast using __typeof__ +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof__ +PASS: gdb.cp/casts.exp: old-style cast using __typeof +PASS: gdb.cp/casts.exp: static_cast using __typeof +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof +PASS: gdb.cp/casts.exp: old-style cast using __decltype +PASS: gdb.cp/casts.exp: static_cast using __decltype +PASS: gdb.cp/casts.exp: reinterpret_cast using __decltype +PASS: gdb.cp/casts.exp: whatis __decltype(*a) +PASS: gdb.cp/casts.exp: invalid dynamic_cast +PASS: gdb.cp/casts.exp: dynamic_cast of 0 to void* +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast +PASS: gdb.cp/casts.exp: dynamic_cast upcast to unique base +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast to reference +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast to intermediate class +PASS: gdb.cp/casts.exp: dynamic_cast to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast to reference to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast unique downcast +PASS: gdb.cp/casts.exp: dynamic_cast to sibling +Running ./gdb.cp/class2.exp ... +PASS: gdb.cp/class2.exp: set print object off +PASS: gdb.cp/class2.exp: print alpha at marker return 0 +PASS: gdb.cp/class2.exp: print beta at marker return 0 +PASS: gdb.cp/class2.exp: print * aap at marker return 0 +PASS: gdb.cp/class2.exp: print * bbp at marker return 0 +PASS: gdb.cp/class2.exp: print * abp at marker return 0, s-p-o off +PASS: gdb.cp/class2.exp: print * (B *) abp at marker return 0 +PASS: gdb.cp/class2.exp: print object with no data fields +PASS: gdb.cp/class2.exp: set print object on +PASS: gdb.cp/class2.exp: p acp +PASS: gdb.cp/class2.exp: p acp->c1 +PASS: gdb.cp/class2.exp: p acp->c2 +Running ./gdb.cp/classes.exp ... +PASS: gdb.cp/classes.exp: ptype struct default_public_struct +PASS: gdb.cp/classes.exp: ptype struct explicit_public_struct +PASS: gdb.cp/classes.exp: ptype struct protected_struct +PASS: gdb.cp/classes.exp: ptype struct private_struct +PASS: gdb.cp/classes.exp: ptype struct mixed_protection_struct +PASS: gdb.cp/classes.exp: ptype class public_class +PASS: gdb.cp/classes.exp: ptype class protected_class +PASS: gdb.cp/classes.exp: ptype class default_private_class +PASS: gdb.cp/classes.exp: ptype class explicit_private_class +PASS: gdb.cp/classes.exp: ptype class mixed_protection_class +PASS: gdb.cp/classes.exp: ptype class A +PASS: gdb.cp/classes.exp: ptype class B +PASS: gdb.cp/classes.exp: ptype class C +PASS: gdb.cp/classes.exp: ptype class D +PASS: gdb.cp/classes.exp: ptype class E +PASS: gdb.cp/classes.exp: ptype class Static +PASS: gdb.cp/classes.exp: ptype class vA +PASS: gdb.cp/classes.exp: ptype class vB +PASS: gdb.cp/classes.exp: ptype class vC +PASS: gdb.cp/classes.exp: ptype class vD +PASS: gdb.cp/classes.exp: ptype class vE +PASS: gdb.cp/classes.exp: ptype class Base1 +PASS: gdb.cp/classes.exp: ptype class Foo +PASS: gdb.cp/classes.exp: ptype class Bar +PASS: gdb.cp/classes.exp: print g_A.a +PASS: gdb.cp/classes.exp: print g_A.x +PASS: gdb.cp/classes.exp: print g_B.b +PASS: gdb.cp/classes.exp: print g_B.x +PASS: gdb.cp/classes.exp: print g_C.c +PASS: gdb.cp/classes.exp: print g_C.x +PASS: gdb.cp/classes.exp: print g_D.d +PASS: gdb.cp/classes.exp: print g_D.x +PASS: gdb.cp/classes.exp: print g_E.e +PASS: gdb.cp/classes.exp: print g_E.x +PASS: gdb.cp/classes.exp: print g_A.b +PASS: gdb.cp/classes.exp: print g_B.c +PASS: gdb.cp/classes.exp: print g_B.d +PASS: gdb.cp/classes.exp: print g_C.b +PASS: gdb.cp/classes.exp: print g_C.d +PASS: gdb.cp/classes.exp: print g_D.e +PASS: gdb.cp/classes.exp: print g_A.y +PASS: gdb.cp/classes.exp: print g_B.z +PASS: gdb.cp/classes.exp: print g_C.q +PASS: gdb.cp/classes.exp: print g_D.p +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_B) +PASS: gdb.cp/classes.exp: unrelated class *param +PASS: gdb.cp/classes.exp: unrelated class ¶m +PASS: gdb.cp/classes.exp: unrelated class param +PASS: gdb.cp/classes.exp: continue to enums2(\(\)|) +PASS: gdb.cp/classes.exp: print obj_with_enum (1) +PASS: gdb.cp/classes.exp: next +PASS: gdb.cp/classes.exp: print obj_with_enum (2) +PASS: gdb.cp/classes.exp: print obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum +PASS: gdb.cp/classes.exp: print (ClassWithEnum::PrivEnum) 42 +PASS: gdb.cp/classes.exp: print ('ClassWithEnum::PrivEnum') 42 +PASS: gdb.cp/classes.exp: print Bar::z +PASS: gdb.cp/classes.exp: print &Foo::x +PASS: gdb.cp/classes.exp: print (int)&Foo::x +PASS: gdb.cp/classes.exp: print (int)&Bar::y == 2*sizeof(int) +PASS: gdb.cp/classes.exp: ptype Bar::z +PASS: gdb.cp/classes.exp: ptype &Bar::z +PASS: gdb.cp/classes.exp: print (int)pmi == sizeof(int) +PASS: gdb.cp/classes.exp: print Foo::st +PASS: gdb.cp/classes.exp: print bar.st +PASS: gdb.cp/classes.exp: print &foo.st +PASS: gdb.cp/classes.exp: print &Bar::st +PASS: gdb.cp/classes.exp: print *$ +PASS: gdb.cp/classes.exp: set print static-members off +PASS: gdb.cp/classes.exp: print csi without static members +PASS: gdb.cp/classes.exp: print cnsi without static members +PASS: gdb.cp/classes.exp: set print static-members on +PASS: gdb.cp/classes.exp: print csi with static members +PASS: gdb.cp/classes.exp: print cnsi with static members +PASS: gdb.cp/classes.exp: finish from marker_reg1 +PASS: gdb.cp/classes.exp: calling method for small class +FAIL: gdb.cp/classes.exp: print ctor of typedef class +FAIL: gdb.cp/classes.exp: print dtor of typedef class +PASS: gdb.cp/classes.exp: list ByAnyOtherName::times +Running ./gdb.cp/cmpd-minsyms.exp ... +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::a() const' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::b() volatile' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::c() const volatile' +PASS: gdb.cp/cmpd-minsyms.exp: set language c++ +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator == +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator==(GDB<int> const&) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<char>::harder(char) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::harder(int) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at "int GDB<char>::even_harder<int>(char)" +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::simple() +Running ./gdb.cp/converts.exp ... +PASS: gdb.cp/converts.exp: continue to breakpoint: end of main +PASS: gdb.cp/converts.exp: typedef to another typedef +PASS: gdb.cp/converts.exp: typedef to typedef of a typedef +PASS: gdb.cp/converts.exp: Pointer-to-pointer-to-pointer derived to Pointer-to-pointer-to-pointer base. +PASS: gdb.cp/converts.exp: pointer to pointer +PASS: gdb.cp/converts.exp: pointer to array +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to ancestor pointer +PASS: gdb.cp/converts.exp: pointer to void pointer +PASS: gdb.cp/converts.exp: pointer to void pointer pointer +PASS: gdb.cp/converts.exp: pointer to boolean +PASS: gdb.cp/converts.exp: pointer to long int +PASS: gdb.cp/converts.exp: pointer pointer to void pointer +PASS: gdb.cp/converts.exp: pointer pointer to pointer pointer +PASS: gdb.cp/converts.exp: pointer pointer to array of arrays +PASS: gdb.cp/converts.exp: pointer pointer to array of pointers +PASS: gdb.cp/converts.exp: pointer pointer to array of wrong pointers +PASS: gdb.cp/converts.exp: check all parameters for badness +PASS: gdb.cp/converts.exp: null pointer conversion +PASS: gdb.cp/converts.exp: p foo3_1 (0, 1) +PASS: gdb.cp/converts.exp: p foo3_1 (0, (const char**) 1) +PASS: gdb.cp/converts.exp: p foo3_2 (0, 0) +PASS: gdb.cp/converts.exp: p foo3_2 (0, (char const**) 0) +PASS: gdb.cp/converts.exp: p foo1_7(0) +PASS: gdb.cp/converts.exp: p foo1_7(integer) +PASS: gdb.cp/converts.exp: p foo1_7(long_int) +PASS: gdb.cp/converts.exp: p foo1_7(*a) +PASS: gdb.cp/converts.exp: p foo1_7(MY_A) +PASS: gdb.cp/converts.exp: p foo1_7(&foo1_7) +PASS: gdb.cp/converts.exp: p foo1_7(&A::member_) +PASS: gdb.cp/converts.exp: p foo1_7(a) +PASS: gdb.cp/converts.exp: p foo1_7(fp) +PASS: gdb.cp/converts.exp: p foo1_7(dp) +PASS: gdb.cp/converts.exp: p foo1_7(-1.23) +PASS: gdb.cp/converts.exp: p foo1_7(ta) +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: set check type off +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_2 (1,1) +Running ./gdb.cp/cpcompletion.exp ... +PASS: gdb.cp/cpcompletion.exp: complete class methods +PASS: gdb.cp/cpcompletion.exp: complete class methods beginning with F +PASS: gdb.cp/cpcompletion.exp: complete p foo1.g +PASS: gdb.cp/cpcompletion.exp: complete p foo1.base +PASS: gdb.cp/cpcompletion.exp: complete p foo1.Fo +PASS: gdb.cp/cpcompletion.exp: complete p a.g +Running ./gdb.cp/cpexprs.exp ... +PASS: gdb.cp/cpexprs.exp: set listsize 1 +PASS: gdb.cp/cpexprs.exp: print base1::a_function +FAIL: gdb.cp/cpexprs.exp: print base1::base1(int) +FAIL: gdb.cp/cpexprs.exp: print base1::base1(void) +PASS: gdb.cp/cpexprs.exp: print base2::a_function +FAIL: gdb.cp/cpexprs.exp: print base2::base2 +FAIL: gdb.cp/cpexprs.exp: print base::base(int) +FAIL: gdb.cp/cpexprs.exp: print base::base(void) +PASS: gdb.cp/cpexprs.exp: print base::operator char* +PASS: gdb.cp/cpexprs.exp: print base::operator delete +PASS: gdb.cp/cpexprs.exp: print base::operator delete[] +PASS: gdb.cp/cpexprs.exp: print base::operator fluff* +PASS: gdb.cp/cpexprs.exp: print base::operator fluff** +PASS: gdb.cp/cpexprs.exp: print base::operator int +PASS: gdb.cp/cpexprs.exp: print base::operator new +PASS: gdb.cp/cpexprs.exp: print base::operator new[] +PASS: gdb.cp/cpexprs.exp: print base::operator! +PASS: gdb.cp/cpexprs.exp: print base::operator!= +PASS: gdb.cp/cpexprs.exp: print base::operator% +PASS: gdb.cp/cpexprs.exp: print base::operator%= +PASS: gdb.cp/cpexprs.exp: print base::operator& +PASS: gdb.cp/cpexprs.exp: print base::operator&& +PASS: gdb.cp/cpexprs.exp: print base::operator&= +PASS: gdb.cp/cpexprs.exp: print base::operator() +PASS: gdb.cp/cpexprs.exp: print base::operator* +PASS: gdb.cp/cpexprs.exp: print base::operator*= +PASS: gdb.cp/cpexprs.exp: print base::operator+ +PASS: gdb.cp/cpexprs.exp: print base::operator++ +PASS: gdb.cp/cpexprs.exp: print base::operator+= +PASS: gdb.cp/cpexprs.exp: print base::operator- +PASS: gdb.cp/cpexprs.exp: print base::operator-- +PASS: gdb.cp/cpexprs.exp: print base::operator-= +PASS: gdb.cp/cpexprs.exp: print base::operator/ +PASS: gdb.cp/cpexprs.exp: print base::operator/= +PASS: gdb.cp/cpexprs.exp: print base::operator< +PASS: gdb.cp/cpexprs.exp: print base::operator<< +PASS: gdb.cp/cpexprs.exp: print base::operator<<= +PASS: gdb.cp/cpexprs.exp: print base::operator<= +PASS: gdb.cp/cpexprs.exp: print base::operator= +PASS: gdb.cp/cpexprs.exp: print base::operator== +PASS: gdb.cp/cpexprs.exp: print base::operator> +PASS: gdb.cp/cpexprs.exp: print base::operator>= +PASS: gdb.cp/cpexprs.exp: print base::operator>> +PASS: gdb.cp/cpexprs.exp: print base::operator>>= +PASS: gdb.cp/cpexprs.exp: print base::operator[] +PASS: gdb.cp/cpexprs.exp: print base::operator^ +PASS: gdb.cp/cpexprs.exp: print base::operator^= +PASS: gdb.cp/cpexprs.exp: print base::operator| +PASS: gdb.cp/cpexprs.exp: print base::operator|= +PASS: gdb.cp/cpexprs.exp: print base::operator|| +PASS: gdb.cp/cpexprs.exp: print base::operator~ +PASS: gdb.cp/cpexprs.exp: print base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: print base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: print base::overload(int) const +PASS: gdb.cp/cpexprs.exp: print base::overload(long) const +PASS: gdb.cp/cpexprs.exp: print base::overload(short) const +PASS: gdb.cp/cpexprs.exp: print base::overload(void) const +FAIL: gdb.cp/cpexprs.exp: print base::~base +PASS: gdb.cp/cpexprs.exp: print derived::a_function +FAIL: gdb.cp/cpexprs.exp: print derived::derived +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print policy1::function +FAIL: gdb.cp/cpexprs.exp: print policy1::policy +PASS: gdb.cp/cpexprs.exp: print policy2::function +FAIL: gdb.cp/cpexprs.exp: print policy2::policy +PASS: gdb.cp/cpexprs.exp: print policy3::function +FAIL: gdb.cp/cpexprs.exp: print policy3::policy +PASS: gdb.cp/cpexprs.exp: print policy4::function +FAIL: gdb.cp/cpexprs.exp: print policy4::policy +PASS: gdb.cp/cpexprs.exp: print policyd1::function +FAIL: gdb.cp/cpexprs.exp: print policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd2::function +FAIL: gdb.cp/cpexprs.exp: print policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd3::function +FAIL: gdb.cp/cpexprs.exp: print policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd4::function +FAIL: gdb.cp/cpexprs.exp: print policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd5::function +FAIL: gdb.cp/cpexprs.exp: print policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::~policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: print tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: print test_function +PASS: gdb.cp/cpexprs.exp: list base1::a_function +PASS: gdb.cp/cpexprs.exp: list base1::base1(int) +PASS: gdb.cp/cpexprs.exp: list base1::base1(void) +PASS: gdb.cp/cpexprs.exp: list base2::a_function +PASS: gdb.cp/cpexprs.exp: list base2::base2 +PASS: gdb.cp/cpexprs.exp: list base::base(int) +PASS: gdb.cp/cpexprs.exp: list base::base(void) +PASS: gdb.cp/cpexprs.exp: list base::operator char* +PASS: gdb.cp/cpexprs.exp: list base::operator delete +PASS: gdb.cp/cpexprs.exp: list base::operator delete[] +PASS: gdb.cp/cpexprs.exp: list base::operator fluff* +PASS: gdb.cp/cpexprs.exp: list base::operator fluff** +PASS: gdb.cp/cpexprs.exp: list base::operator int +PASS: gdb.cp/cpexprs.exp: list base::operator new +PASS: gdb.cp/cpexprs.exp: list base::operator new[] +PASS: gdb.cp/cpexprs.exp: list base::operator! +PASS: gdb.cp/cpexprs.exp: list base::operator!= +PASS: gdb.cp/cpexprs.exp: list base::operator% +PASS: gdb.cp/cpexprs.exp: list base::operator%= +PASS: gdb.cp/cpexprs.exp: list base::operator& +PASS: gdb.cp/cpexprs.exp: list base::operator&& +PASS: gdb.cp/cpexprs.exp: list base::operator&= +PASS: gdb.cp/cpexprs.exp: list base::operator() +PASS: gdb.cp/cpexprs.exp: list base::operator* +PASS: gdb.cp/cpexprs.exp: list base::operator*= +PASS: gdb.cp/cpexprs.exp: list base::operator+ +PASS: gdb.cp/cpexprs.exp: list base::operator++ +PASS: gdb.cp/cpexprs.exp: list base::operator+= +PASS: gdb.cp/cpexprs.exp: list base::operator- +PASS: gdb.cp/cpexprs.exp: list base::operator-- +PASS: gdb.cp/cpexprs.exp: list base::operator-= +PASS: gdb.cp/cpexprs.exp: list base::operator/ +PASS: gdb.cp/cpexprs.exp: list base::operator/= +PASS: gdb.cp/cpexprs.exp: list base::operator< +PASS: gdb.cp/cpexprs.exp: list base::operator<< +PASS: gdb.cp/cpexprs.exp: list base::operator<<= +PASS: gdb.cp/cpexprs.exp: list base::operator<= +PASS: gdb.cp/cpexprs.exp: list base::operator= +PASS: gdb.cp/cpexprs.exp: list base::operator== +PASS: gdb.cp/cpexprs.exp: list base::operator> +PASS: gdb.cp/cpexprs.exp: list base::operator>= +PASS: gdb.cp/cpexprs.exp: list base::operator>> +PASS: gdb.cp/cpexprs.exp: list base::operator>>= +PASS: gdb.cp/cpexprs.exp: list base::operator[] +PASS: gdb.cp/cpexprs.exp: list base::operator^ +PASS: gdb.cp/cpexprs.exp: list base::operator^= +PASS: gdb.cp/cpexprs.exp: list base::operator| +PASS: gdb.cp/cpexprs.exp: list base::operator|= +PASS: gdb.cp/cpexprs.exp: list base::operator|| +PASS: gdb.cp/cpexprs.exp: list base::operator~ +PASS: gdb.cp/cpexprs.exp: list base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: list base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: list base::overload(int) const +PASS: gdb.cp/cpexprs.exp: list base::overload(long) const +PASS: gdb.cp/cpexprs.exp: list base::overload(short) const +PASS: gdb.cp/cpexprs.exp: list base::overload(void) const +PASS: gdb.cp/cpexprs.exp: list base::~base +PASS: gdb.cp/cpexprs.exp: list derived::a_function +PASS: gdb.cp/cpexprs.exp: list derived::derived +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list policy1::function +PASS: gdb.cp/cpexprs.exp: list policy1::policy +PASS: gdb.cp/cpexprs.exp: list policy2::function +PASS: gdb.cp/cpexprs.exp: list policy2::policy +PASS: gdb.cp/cpexprs.exp: list policy3::function +PASS: gdb.cp/cpexprs.exp: list policy3::policy +PASS: gdb.cp/cpexprs.exp: list policy4::function +PASS: gdb.cp/cpexprs.exp: list policy4::policy +PASS: gdb.cp/cpexprs.exp: list policyd1::function +PASS: gdb.cp/cpexprs.exp: list policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd2::function +PASS: gdb.cp/cpexprs.exp: list policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd3::function +PASS: gdb.cp/cpexprs.exp: list policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd4::function +PASS: gdb.cp/cpexprs.exp: list policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd5::function +PASS: gdb.cp/cpexprs.exp: list policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: list tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: list test_function +PASS: gdb.cp/cpexprs.exp: continue to base1::a_function +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(int) +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(void) +PASS: gdb.cp/cpexprs.exp: continue to base2::a_function +PASS: gdb.cp/cpexprs.exp: continue to base2::base2 +PASS: gdb.cp/cpexprs.exp: continue to base::base(int) +PASS: gdb.cp/cpexprs.exp: continue to base::base(void) +PASS: gdb.cp/cpexprs.exp: continue to base::operator char* +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff* +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff** +PASS: gdb.cp/cpexprs.exp: continue to base::operator int +PASS: gdb.cp/cpexprs.exp: continue to base::operator new +PASS: gdb.cp/cpexprs.exp: continue to base::operator new[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator! +PASS: gdb.cp/cpexprs.exp: continue to base::operator!= +PASS: gdb.cp/cpexprs.exp: continue to base::operator% +PASS: gdb.cp/cpexprs.exp: continue to base::operator%= +PASS: gdb.cp/cpexprs.exp: continue to base::operator& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&= +PASS: gdb.cp/cpexprs.exp: continue to base::operator() +PASS: gdb.cp/cpexprs.exp: continue to base::operator* +PASS: gdb.cp/cpexprs.exp: continue to base::operator*= +PASS: gdb.cp/cpexprs.exp: continue to base::operator+ +PASS: gdb.cp/cpexprs.exp: continue to base::operator++ +PASS: gdb.cp/cpexprs.exp: continue to base::operator+= +PASS: gdb.cp/cpexprs.exp: continue to base::operator- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-= +PASS: gdb.cp/cpexprs.exp: continue to base::operator/ +PASS: gdb.cp/cpexprs.exp: continue to base::operator/= +PASS: gdb.cp/cpexprs.exp: continue to base::operator< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator= +PASS: gdb.cp/cpexprs.exp: continue to base::operator== +PASS: gdb.cp/cpexprs.exp: continue to base::operator> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator>> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator^ +PASS: gdb.cp/cpexprs.exp: continue to base::operator^= +PASS: gdb.cp/cpexprs.exp: continue to base::operator| +PASS: gdb.cp/cpexprs.exp: continue to base::operator|= +PASS: gdb.cp/cpexprs.exp: continue to base::operator|| +PASS: gdb.cp/cpexprs.exp: continue to base::operator~ +PASS: gdb.cp/cpexprs.exp: continue to base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(int) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(long) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(short) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(void) const +PASS: gdb.cp/cpexprs.exp: continue to base::~base +PASS: gdb.cp/cpexprs.exp: continue to derived::a_function +PASS: gdb.cp/cpexprs.exp: continue to derived::derived +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to policy1::function +PASS: gdb.cp/cpexprs.exp: continue to policy1::policy +PASS: gdb.cp/cpexprs.exp: continue to policy2::function +PASS: gdb.cp/cpexprs.exp: continue to policy2::policy +PASS: gdb.cp/cpexprs.exp: continue to policy3::function +PASS: gdb.cp/cpexprs.exp: continue to policy3::policy +PASS: gdb.cp/cpexprs.exp: continue to policy4::function +PASS: gdb.cp/cpexprs.exp: continue to policy4::policy +PASS: gdb.cp/cpexprs.exp: continue to policyd1::function +PASS: gdb.cp/cpexprs.exp: continue to policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd1::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd2::function +PASS: gdb.cp/cpexprs.exp: continue to policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd2::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd3::function +PASS: gdb.cp/cpexprs.exp: continue to policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd3::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd4::function +PASS: gdb.cp/cpexprs.exp: continue to policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd4::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd5::function +PASS: gdb.cp/cpexprs.exp: continue to policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd5::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int)' +PASS: gdb.cp/cpexprs.exp: p CV::m(int) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p CV_f(int) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::t) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::i) +Running ./gdb.cp/cplabel.exp ... +PASS: gdb.cp/cplabel.exp: break foo::bar:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::bar:get_out_of_here +PASS: gdb.cp/cplabel.exp: break foo::baz:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::baz:get_out_of_here +Running ./gdb.cp/cplusfuncs.exp ... +PASS: gdb.cp/cplusfuncs.exp: set width 0 +PASS: gdb.cp/cplusfuncs.exp: set language c++ +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_comma +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_foo_ref +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_int_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_int +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_typedef +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(void)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(signed char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(float)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(double)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator++(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator,(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator==(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator||(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator~(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator--(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator[](foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator()(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new[] +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator int(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator char*(void) +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc1 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc2 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc3 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc4 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc5 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc6 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc7 +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator++(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator,(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator==(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator||(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator~(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator--(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\[\](" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator new(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator delete(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator int(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator()(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator char\*(" +PASS: gdb.cp/cplusfuncs.exp: list foo::operator int* +Running ./gdb.cp/cp-relocate.exp ... +PASS: gdb.cp/cp-relocate.exp: info functions +PASS: gdb.cp/cp-relocate.exp: get address of func<1>(int) +PASS: gdb.cp/cp-relocate.exp: get address of func<2>(int) +PASS: gdb.cp/cp-relocate.exp: get address of caller +PASS: gdb.cp/cp-relocate.exp: C++ functions have different addresses +PASS: gdb.cp/cp-relocate.exp: info file +PASS: gdb.cp/cp-relocate.exp: add-symbol-file cp-relocate.o +PASS: gdb.cp/cp-relocate.exp: break *func<1>(int) +PASS: gdb.cp/cp-relocate.exp: break *func<2>(int) +Running ./gdb.cp/ctti.exp ... +PASS: gdb.cp/ctti.exp: continue to breakpoint: marker add1 +PASS: gdb.cp/ctti.exp: print c +PASS: gdb.cp/ctti.exp: print f +PASS: gdb.cp/ctti.exp: print i +Running ./gdb.cp/debug-expr.exp ... +PASS: gdb.cp/debug-expr.exp: set language c++ +PASS: gdb.cp/debug-expr.exp: set debug expression 1 +PASS: gdb.cp/debug-expr.exp: print static_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print reinterpret_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print dynamic_cast<void*>(0) +Running ./gdb.cp/demangle.exp ... +PASS: gdb.cp/demangle.exp: set language c++ +PASS: gdb.cp/demangle.exp: set width 0 +PASS: gdb.cp/demangle.exp: lucid: set demangle-style +PASS: gdb.cp/demangle.exp: lucid: check demangling style +PASS: gdb.cp/demangle.exp: lucid: WS__FR7istream +PASS: gdb.cp/demangle.exp: lucid: __aa__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __aad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aer__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __als__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amd__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ami__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aor__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __apl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ars__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFR7istream +PASS: gdb.cp/demangle.exp: lucid: __as__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__3iosFR3ios +PASS: gdb.cp/demangle.exp: lucid: __cl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __cm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __co__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPc +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPci +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFPciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10smanip_intFPFR3iosi_R3iosi +PASS: gdb.cp/demangle.exp: lucid: __ct__11c_exceptionFPcRC7complexT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFv +PASS: gdb.cp/demangle.exp: lucid: __ct__11smanip_longFPFR3iosl_R3iosl +PASS: gdb.cp/demangle.exp: lucid: __ct__11stdiostreamFP4FILE +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPFl_PvPFPv_v +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPUciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFi +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFv +PASS: gdb.cp/demangle.exp: lucid: __ct__13strstreambaseFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiN31 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiPCc +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: __ct__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7filebufFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambufiP7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiT1P7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFiPc +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __ct__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dl__3fooSFPv +PASS: gdb.cp/demangle.exp: lucid: __dl__FPv +PASS: gdb.cp/demangle.exp: lucid: __dt__10istrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __dv__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __er__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ge__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __gt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __le__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPCc +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPv +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUl +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFd +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFl +PASS: gdb.cp/demangle.exp: lucid: __ls__FR7ostream7complex +PASS: gdb.cp/demangle.exp: lucid: __lt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __md__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __mi__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __mm__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ne__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __nt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __nw__3fooSFi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUiPv +PASS: gdb.cp/demangle.exp: lucid: __oo__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __opPc__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __opi__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __or__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pp__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __pt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __rm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR7istream_R7istream +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPUc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUs +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRd +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRs +PASS: gdb.cp/demangle.exp: lucid: __rs__FR7istreamR7complex +PASS: gdb.cp/demangle.exp: lucid: __vc__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __vtbl__10istrstream +PASS: gdb.cp/demangle.exp: lucid: __vtbl__17ostream__iostream__19iostream_withassign +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios__13strstreambase +KFAIL: gdb.cp/demangle.exp: lucid: __vtbl__3foo__vt_cc_main_ (PRMS: gdb/945) +PASS: gdb.cp/demangle.exp: lucid: abs__F7complex +PASS: gdb.cp/demangle.exp: lucid: allocate__9streambufFv +PASS: gdb.cp/demangle.exp: lucid: attach__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: bitalloc__3iosSFv +PASS: gdb.cp/demangle.exp: lucid: chr__FiT1 +PASS: gdb.cp/demangle.exp: lucid: complex_error__FR11c_exception +PASS: gdb.cp/demangle.exp: lucid: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complicated_put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: conv10__FlPc +PASS: gdb.cp/demangle.exp: lucid: conv16__FUlPc +PASS: gdb.cp/demangle.exp: lucid: dec__FR3ios +PASS: gdb.cp/demangle.exp: lucid: dec__Fli +PASS: gdb.cp/demangle.exp: lucid: dofield__FP7ostreamPciT2T3 +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFl +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFv +PASS: gdb.cp/demangle.exp: lucid: foo__FiN31 +PASS: gdb.cp/demangle.exp: lucid: foo__FiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: foo___3barFl +PASS: gdb.cp/demangle.exp: lucid: form__FPCce +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFR9streambufc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPUcic +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: ignore__7istreamFiT1 +PASS: gdb.cp/demangle.exp: lucid: init__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: init__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: initcount__13Iostream_init +PASS: gdb.cp/demangle.exp: lucid: ipfx__7istreamFi +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFUc +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: open__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: open__7filebufFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FSc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fd +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Ff +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fv +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN21 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN31 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN41 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN51 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN61 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN71 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN81 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91N11 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiT1 +PASS: gdb.cp/demangle.exp: lucid: polar__FdT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexd +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexi +PASS: gdb.cp/demangle.exp: lucid: pow__Fd7complex +PASS: gdb.cp/demangle.exp: lucid: pstart__FPciT2 +PASS: gdb.cp/demangle.exp: lucid: put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: read__7istreamFPci +PASS: gdb.cp/demangle.exp: lucid: resetiosflags__FR3iosl +PASS: gdb.cp/demangle.exp: lucid: restore_errno__FRi +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: seekg__7istreamFl8seek_dir +PASS: gdb.cp/demangle.exp: lucid: seekoff__12strstreambufFl8seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekpos__9streambufFli +PASS: gdb.cp/demangle.exp: lucid: set_new_handler__FPFv_v +PASS: gdb.cp/demangle.exp: lucid: setb__9streambufFPcT1i +PASS: gdb.cp/demangle.exp: lucid: setb__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setbuf__11fstreambaseFPci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPUci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPciT2 +PASS: gdb.cp/demangle.exp: lucid: setf__3iosFlT1 +PASS: gdb.cp/demangle.exp: lucid: setfill__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setg__9streambufFPcN21 +PASS: gdb.cp/demangle.exp: lucid: setp__9streambufFPcT1 +PASS: gdb.cp/demangle.exp: lucid: sputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: str__FPCci +PASS: gdb.cp/demangle.exp: lucid: tie__3iosFP7ostream +PASS: gdb.cp/demangle.exp: lucid: uconv10__FUlPc +PASS: gdb.cp/demangle.exp: lucid: write__7ostreamFPCci +PASS: gdb.cp/demangle.exp: lucid: xget__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: xsgetn__9streambufFPci +PASS: gdb.cp/demangle.exp: lucid: xsputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: set demangle-style +PASS: gdb.cp/demangle.exp: gnu: check demangling style +PASS: gdb.cp/demangle.exp: gnu: Abort__FP6EditoriPCc +PASS: gdb.cp/demangle.exp: gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue +PASS: gdb.cp/demangle.exp: gnu: Append__15NameChooserViewPCc +PASS: gdb.cp/demangle.exp: gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic +PASS: gdb.cp/demangle.exp: gnu: AtEnd__13ivRubberGroup +PASS: gdb.cp/demangle.exp: gnu: BgFilter__9ivTSolverP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: BitPatterntoa__FRC10BitPatternccc +PASS: gdb.cp/demangle.exp: gnu: Check__6UArrayi +PASS: gdb.cp/demangle.exp: gnu: CoreConstDecls__8TextCodeR7ostream +PASS: gdb.cp/demangle.exp: gnu: Detach__8StateVarP12StateVarView +PASS: gdb.cp/demangle.exp: gnu: Done__9ComponentG8Iterator +PASS: gdb.cp/demangle.exp: gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii +PASS: gdb.cp/demangle.exp: gnu: Edit__12StringEditorPCcii +PASS: gdb.cp/demangle.exp: gnu: Effect__11RelateManipR7ivEvent +PASS: gdb.cp/demangle.exp: gnu: FilterName__FPCc +PASS: gdb.cp/demangle.exp: gnu: Filter__6PSTextPCci +PASS: gdb.cp/demangle.exp: gnu: FindColor__7CatalogPCciii +PASS: gdb.cp/demangle.exp: gnu: FindFixed__FRP4CNetP4CNet +PASS: gdb.cp/demangle.exp: gnu: FindFont__7CatalogPCcN21 +PASS: gdb.cp/demangle.exp: gnu: Fix48_abort__FR8twolongs +PASS: gdb.cp/demangle.exp: gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2 +PASS: gdb.cp/demangle.exp: gnu: GetBgColor__C9ivPainter +PASS: gdb.cp/demangle.exp: gnu: Iisdouble__FPC6IntRep +PASS: gdb.cp/demangle.exp: gnu: InsertBody__15H_PullrightMenuii +PASS: gdb.cp/demangle.exp: gnu: InsertCharacter__9TextManipc +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1 +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi +PASS: gdb.cp/demangle.exp: gnu: IsADirectory__FPCcR4stat +PASS: gdb.cp/demangle.exp: gnu: IsAGroup__FP11GraphicViewP11GraphicComp +PASS: gdb.cp/demangle.exp: gnu: IsA__10ButtonCodeUl +PASS: gdb.cp/demangle.exp: gnu: ReadName__FR7istreamPc +PASS: gdb.cp/demangle.exp: gnu: Redraw__13StringBrowseriiii +PASS: gdb.cp/demangle.exp: gnu: Rotate__13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Rotated__C13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Round__Ff +PASS: gdb.cp/demangle.exp: gnu: SetExport__16MemberSharedNameUi +PASS: gdb.cp/demangle.exp: gnu: Set__14ivControlState13ControlStatusUi +PASS: gdb.cp/demangle.exp: gnu: Set__5DFacePcii +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2 +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement +PASS: gdb.cp/demangle.exp: gnu: VOrder__9ivTSolverUiRP12ivInteractorT2 +PASS: gdb.cp/demangle.exp: gnu: Valid__7CatalogPCcRP4Tool +PASS: gdb.cp/demangle.exp: gnu: _10PageButton$__both +PASS: gdb.cp/demangle.exp: gnu: _3RNG$singleMantissa +PASS: gdb.cp/demangle.exp: gnu: _5IComp$_release +PASS: gdb.cp/demangle.exp: gnu: _$_10BitmapComp +PASS: gdb.cp/demangle.exp: gnu: _$_9__io_defs +PASS: gdb.cp/demangle.exp: gnu: _$_Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: _$_Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __10ivTelltaleiP7ivGlyph +PASS: gdb.cp/demangle.exp: gnu: __10ivViewportiP12ivInteractorUi +PASS: gdb.cp/demangle.exp: gnu: __10ostrstream +PASS: gdb.cp/demangle.exp: gnu: __10ostrstreamPcii +PASS: gdb.cp/demangle.exp: gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui +PASS: gdb.cp/demangle.exp: gnu: __11BitmapTablei +PASS: gdb.cp/demangle.exp: gnu: __12ViewportCodeP12ViewportComp +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_BorderiPCci +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_Borderii +PASS: gdb.cp/demangle.exp: gnu: __12ivBackgroundiP7ivGlyphPC7ivColor +PASS: gdb.cp/demangle.exp: gnu: __12ivBreak_Listl +PASS: gdb.cp/demangle.exp: gnu: __14TextInteractoriPCcUi +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiPCcP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __20DisplayList_IteratorR11DisplayList +PASS: gdb.cp/demangle.exp: gnu: __3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __3fooiN31 +PASS: gdb.cp/demangle.exp: gnu: __3fooiPCc +PASS: gdb.cp/demangle.exp: gnu: __3fooiRT0iT2iT2 +PASS: gdb.cp/demangle.exp: gnu: __6GetOptiPPcPCc +PASS: gdb.cp/demangle.exp: gnu: __6KeyMapPT0 +PASS: gdb.cp/demangle.exp: gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData +PASS: gdb.cp/demangle.exp: gnu: __7procbufPCci +PASS: gdb.cp/demangle.exp: gnu: __8ArrowCmdP6EditorUiUi +PASS: gdb.cp/demangle.exp: gnu: __9F_EllipseiiiiP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __9FrameDataP9FrameCompi +PASS: gdb.cp/demangle.exp: gnu: __9HVGraphicP9CanvasVarP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: __Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __aa__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __adv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aer__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __als__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __amd__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ami__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__3FixRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix16i +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix32RT0 +PASS: gdb.cp/demangle.exp: gnu: __aor__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __apl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ars__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __as__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__6Normal +PASS: gdb.cp/demangle.exp: gnu: __cl__6Stringii +PASS: gdb.cp/demangle.exp: gnu: __cm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __co__3foo +PASS: gdb.cp/demangle.exp: gnu: __dl__3fooPv +PASS: gdb.cp/demangle.exp: gnu: __dv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __er__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ge__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __gt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __le__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamR3Fix +PASS: gdb.cp/demangle.exp: gnu: __lt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __md__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mi__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ml__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mm__3fooi +PASS: gdb.cp/demangle.exp: gnu: __ne__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7ComplexT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7Complexd +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC9SubStringRC6String +PASS: gdb.cp/demangle.exp: gnu: __nt__3foo +PASS: gdb.cp/demangle.exp: gnu: __nw__3fooi +PASS: gdb.cp/demangle.exp: gnu: __oo__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __opPc__3foo +PASS: gdb.cp/demangle.exp: gnu: __opi__3foo +PASS: gdb.cp/demangle.exp: gnu: __or__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pp__3fooi +PASS: gdb.cp/demangle.exp: gnu: __rf__3foo +PASS: gdb.cp/demangle.exp: gnu: __rm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __rs__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __vc__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: _gsub__6StringRC5RegexPCci +PASS: gdb.cp/demangle.exp: gnu: _new_Fix__FUs +PASS: gdb.cp/demangle.exp: gnu: _vt.foo +PASS: gdb.cp/demangle.exp: gnu: _vt.foo.bar +PASS: gdb.cp/demangle.exp: gnu: _vt$foo +PASS: gdb.cp/demangle.exp: gnu: _vt$foo$bar +PASS: gdb.cp/demangle.exp: gnu: append__7ivGlyphPT0 +PASS: gdb.cp/demangle.exp: gnu: arg__FRC7Complex +PASS: gdb.cp/demangle.exp: gnu: clearok__FP7_win_sti +PASS: gdb.cp/demangle.exp: gnu: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC10BitPattern +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC12BitSubStringi +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRT0 +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntRepT0P6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntReplP6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FRC8RationalT0R8Rational +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerT0R7IntegerT2 +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerlR7IntegerRl +PASS: gdb.cp/demangle.exp: gnu: enable__14DocumentViewerPCcUi +PASS: gdb.cp/demangle.exp: gnu: foo__FiN30 +PASS: gdb.cp/demangle.exp: gnu: foo__FiR3fooiT1iT1 +PASS: gdb.cp/demangle.exp: gnu: foo___3barl +PASS: gdb.cp/demangle.exp: gnu: insert__15ivClippingStacklRP8_XRegion +PASS: gdb.cp/demangle.exp: gnu: insert__16ChooserInfo_ListlR11ChooserInfo +PASS: gdb.cp/demangle.exp: gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep +PASS: gdb.cp/demangle.exp: gnu: leaveok__FP7_win_stc +PASS: gdb.cp/demangle.exp: gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle +PASS: gdb.cp/demangle.exp: gnu: matches__C9BitStringRC10BitPatterni +PASS: gdb.cp/demangle.exp: gnu: matches__C9SubStringRC5Regex +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FSc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fd +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Ff +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fv +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fi +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit +PASS: gdb.cp/demangle.exp: gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation +PASS: gdb.cp/demangle.exp: gnu: poke__8ivRasterUlUlffff +PASS: gdb.cp/demangle.exp: gnu: polar__Fdd +PASS: gdb.cp/demangle.exp: gnu: read__10osStdInputRPCc +PASS: gdb.cp/demangle.exp: gnu: scale__13ivTransformerff +PASS: gdb.cp/demangle.exp: gnu: scanw__12CursesWindowPCce +PASS: gdb.cp/demangle.exp: gnu: scmp__FPCcT0 +PASS: gdb.cp/demangle.exp: gnu: sgetn__7filebufPci +PASS: gdb.cp/demangle.exp: gnu: shift__FP5_FrepiT0 +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSeti +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSetii +PASS: gdb.cp/demangle.exp: gnu: testbit__FRC7Integerl +PASS: gdb.cp/demangle.exp: gnu: text_source__8Documentl +PASS: gdb.cp/demangle.exp: gnu: variance__6Erlangd +PASS: gdb.cp/demangle.exp: gnu: vform__8iostreamPCcPc +PASS: gdb.cp/demangle.exp: gnu: view__14DocumentViewerP8ItemViewP11TabularItem +PASS: gdb.cp/demangle.exp: gnu: xy_extents__11ivExtensionffff +PASS: gdb.cp/demangle.exp: gnu: zero__8osMemoryPvUi +PASS: gdb.cp/demangle.exp: gnu: _2T4$N +PASS: gdb.cp/demangle.exp: gnu: _Q22T42t1$N +PASS: gdb.cp/demangle.exp: gnu: get__2T1 +PASS: gdb.cp/demangle.exp: gnu: get__Q22T11a +PASS: gdb.cp/demangle.exp: gnu: get__Q32T11a1b +PASS: gdb.cp/demangle.exp: gnu: get__Q42T11a1b1c +PASS: gdb.cp/demangle.exp: gnu: get__Q52T11a1b1c1d +PASS: gdb.cp/demangle.exp: gnu: put__2T1i +PASS: gdb.cp/demangle.exp: gnu: put__Q22T11ai +PASS: gdb.cp/demangle.exp: gnu: put__Q32T11a1bi +PASS: gdb.cp/demangle.exp: gnu: put__Q42T11a1b1ci +PASS: gdb.cp/demangle.exp: gnu: put__Q52T11a1b1c1di +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPCv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPCv +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRC3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooR3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11ZcUi +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11Z1tUi +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11ZcPv +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11Z1tPv +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zci +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zc +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1ti +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1t +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0 +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$D$set +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$I$set +PASS: gdb.cp/demangle.exp: gnu: __as__t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCUiPT0 +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi +PASS: gdb.cp/demangle.exp: gnu: __t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t8ListElem1Z5LabelRt4List1Z5Label +PASS: gdb.cp/demangle.exp: gnu: __t8BDDHookV1ZPcRCPc +PASS: gdb.cp/demangle.exp: gnu: _vt$t8BDDHookV1ZPc +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: __eq__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters +PASS: gdb.cp/demangle.exp: gnu: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: foo__I40 +PASS: gdb.cp/demangle.exp: gnu: foo__I_200_ +PASS: gdb.cp/demangle.exp: gnu: foo__I_200 +PASS: gdb.cp/demangle.exp: gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000 +PASS: gdb.cp/demangle.exp: gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator +PASS: gdb.cp/demangle.exp: arm: set demangle-style +PASS: gdb.cp/demangle.exp: arm: check demangling style +PASS: gdb.cp/demangle.exp: arm: __dt__21T5__pt__11_PFiPPdPv_iFv +PASS: gdb.cp/demangle.exp: arm: __ct__1cFi +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_iFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: arm: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: arm: __dt__12T5__pt__3_1xFv +PASS: gdb.cp/demangle.exp: arm: __dt__17T5__pt__8_PFcPv_iFv +PASS: gdb.cp/demangle.exp: arm: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: arm: __ct__21T5__pt__11_PFiPPdPv_iFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: arm: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: arm: put__2T7SFi +PASS: gdb.cp/demangle.exp: arm: __dl__12T5__pt__3_1xSFPv +PASS: gdb.cp/demangle.exp: arm: h__FUc +PASS: gdb.cp/demangle.exp: arm: f__Fic +PASS: gdb.cp/demangle.exp: arm: h__FUi +PASS: gdb.cp/demangle.exp: arm: h__Fci +PASS: gdb.cp/demangle.exp: arm: h__FUl +PASS: gdb.cp/demangle.exp: arm: h__Fcl +PASS: gdb.cp/demangle.exp: arm: h__FUs +PASS: gdb.cp/demangle.exp: arm: h__Fcs +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: arm: X__12T5__pt__3_1x +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: arm: h__FcT1 +PASS: gdb.cp/demangle.exp: arm: f__Ficd +PASS: gdb.cp/demangle.exp: arm: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: arm: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: arm: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: arm: __dl__17T5__pt__8_PFcPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: printf__FPCce +PASS: gdb.cp/demangle.exp: arm: X__17T5__pt__8_PFcPv_i +PASS: gdb.cp/demangle.exp: arm: __ct__12T5__pt__3_1xFi +PASS: gdb.cp/demangle.exp: arm: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: __std__foo +PASS: gdb.cp/demangle.exp: arm: __sti__bar +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: arm: get__2T7SFv +PASS: gdb.cp/demangle.exp: arm: X__21T5__pt__11_PFiPPdPv_i +PASS: gdb.cp/demangle.exp: arm: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_iSFPv +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: h__Fc +PASS: gdb.cp/demangle.exp: arm: h__Fd +PASS: gdb.cp/demangle.exp: arm: h__Ff +PASS: gdb.cp/demangle.exp: arm: h__Fi +PASS: gdb.cp/demangle.exp: arm: f__Fi +PASS: gdb.cp/demangle.exp: arm: h__Fl +PASS: gdb.cp/demangle.exp: arm: h__Fs +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_c +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_i +PASS: gdb.cp/demangle.exp: arm: g__FdCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FfCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FlClT1 +PASS: gdb.cp/demangle.exp: arm: g__FiCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FsCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FcCcT1 +PASS: gdb.cp/demangle.exp: arm: __ct__17T5__pt__8_PFcPv_iFi +PASS: gdb.cp/demangle.exp: arm: f__FicdPc +PASS: gdb.cp/demangle.exp: arm: __nw__FUi +PASS: gdb.cp/demangle.exp: arm: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: arm: put__2T1SFi +PASS: gdb.cp/demangle.exp: arm: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: arm: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: arm: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: arm: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: arm: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: arm: get__2T1SFv +PASS: gdb.cp/demangle.exp: arm: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __dt__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__12T1__pt__3_1tSFPv +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFi +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__11T1__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2 +PASS: gdb.cp/demangle.exp: arm: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: arm: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: hp: set demangle-style +PASS: gdb.cp/demangle.exp: hp: check demangling style +PASS: gdb.cp/demangle.exp: hp: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: hp: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: hp: put__2T7SFi +PASS: gdb.cp/demangle.exp: hp: h__FUc +PASS: gdb.cp/demangle.exp: hp: f__Fic +PASS: gdb.cp/demangle.exp: hp: h__FUi +PASS: gdb.cp/demangle.exp: hp: h__Fci +PASS: gdb.cp/demangle.exp: hp: h__FUl +PASS: gdb.cp/demangle.exp: hp: h__Fcl +PASS: gdb.cp/demangle.exp: hp: h__FUs +PASS: gdb.cp/demangle.exp: hp: h__Fcs +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: hp: h__FcT1 +PASS: gdb.cp/demangle.exp: hp: f__Ficd +PASS: gdb.cp/demangle.exp: hp: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: hp: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: hp: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: hp: printf__FPCce +PASS: gdb.cp/demangle.exp: hp: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: hp: get__2T7SFv +PASS: gdb.cp/demangle.exp: hp: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: hp: h__Fc +PASS: gdb.cp/demangle.exp: hp: h__Fd +PASS: gdb.cp/demangle.exp: hp: h__Ff +PASS: gdb.cp/demangle.exp: hp: h__Fi +PASS: gdb.cp/demangle.exp: hp: f__Fi +PASS: gdb.cp/demangle.exp: hp: h__Fl +PASS: gdb.cp/demangle.exp: hp: h__Fs +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FdCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FfCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FlClT1 +PASS: gdb.cp/demangle.exp: hp: g__FiCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FsCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FcCcT1 +PASS: gdb.cp/demangle.exp: hp: f__FicdPc +PASS: gdb.cp/demangle.exp: hp: __nw__FUi +PASS: gdb.cp/demangle.exp: hp: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: hp: put__2T1SFi +PASS: gdb.cp/demangle.exp: hp: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: hp: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: hp: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: hp: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: hp: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: hp: get__2T1SFv +PASS: gdb.cp/demangle.exp: hp: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: hp: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFiPPdPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__1cFi +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTi__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XT1x__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFcPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFiPPdPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XT1x__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XT1x +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFcPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFcPv_i +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XT1x__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFiPPdPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFiPPdPv_i +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTi__SFPv +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTc +PASS: gdb.cp/demangle.exp: hp: X__2T5XTi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XT1t__SFPv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiUP34__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXUP2701Td__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSP334__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSM__SCFPPd +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67UP4000TRs__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67TRdTFPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: X__6vectorXTiSN67TdTPvUP5TRs +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3foo__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN42A3foo__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_2 +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_19 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v_34 +PASS: gdb.cp/demangle.exp: hp: spec__13Spec<%1,%1.*>XTiTPi_FPi +PASS: gdb.cp/demangle.exp: hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi +PASS: gdb.cp/demangle.exp: hp: add__XTc_FcT1 +PASS: gdb.cp/demangle.exp: hp: add__XTcSP9A5label_FcPPlT1 +PASS: gdb.cp/demangle.exp: hp: add__XTPfTFPd_f_FcT1 +PASS: gdb.cp/demangle.exp: hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv +PASS: gdb.cp/demangle.exp: hp: _Utf390_1__1_9223372036854775807__9223372036854775 +Running ./gdb.cp/derivation.exp ... +PASS: gdb.cp/derivation.exp: before run: ptype A::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A::value_type +PASS: gdb.cp/derivation.exp: before run: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D::value_type +PASS: gdb.cp/derivation.exp: before run: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype E::value_type +PASS: gdb.cp/derivation.exp: before run: whatis E::value_type +PASS: gdb.cp/derivation.exp: before run: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype F::value_type +PASS: gdb.cp/derivation.exp: before run: whatis F::value_type +PASS: gdb.cp/derivation.exp: before run: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype A2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A2::value_type +PASS: gdb.cp/derivation.exp: before run: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D2::value_type +PASS: gdb.cp/derivation.exp: before run: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype Z::value_type +PASS: gdb.cp/derivation.exp: before run: whatis Z::value_type +PASS: gdb.cp/derivation.exp: before run: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: whatis ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: up from marker1 +PASS: gdb.cp/derivation.exp: print value of a_instance +PASS: gdb.cp/derivation.exp: ptype a_instance +PASS: gdb.cp/derivation.exp: print value of d_instance +PASS: gdb.cp/derivation.exp: ptype d_instance +PASS: gdb.cp/derivation.exp: print value of e_instance +PASS: gdb.cp/derivation.exp: ptype e_instance +PASS: gdb.cp/derivation.exp: print value of f_instance +PASS: gdb.cp/derivation.exp: ptype f_instance +PASS: gdb.cp/derivation.exp: ptype g_instance +PASS: gdb.cp/derivation.exp: print value of d_instance.a +PASS: gdb.cp/derivation.exp: print value of d_instance.aa +PASS: gdb.cp/derivation.exp: print value of d_instance.b +PASS: gdb.cp/derivation.exp: print value of d_instance.bb +PASS: gdb.cp/derivation.exp: print value of d_instance.c +PASS: gdb.cp/derivation.exp: print value of d_instance.cc +PASS: gdb.cp/derivation.exp: print value of d_instance.d +PASS: gdb.cp/derivation.exp: print value of d_instance.dd +PASS: gdb.cp/derivation.exp: print value of g_instance.a +PASS: gdb.cp/derivation.exp: print value of g_instance.b +PASS: gdb.cp/derivation.exp: print value of g_instance.c +PASS: gdb.cp/derivation.exp: print value of g_instance.afoo() +PASS: gdb.cp/derivation.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/derivation.exp: print value of g_instance.bfoo() +PASS: gdb.cp/derivation.exp: print value of g_instance.cfoo() +PASS: gdb.cp/derivation.exp: whatis c_instance.c +PASS: gdb.cp/derivation.exp: ptype c_instance.c +PASS: gdb.cp/derivation.exp: whatis g_instance.g +PASS: gdb.cp/derivation.exp: ptype g_instance.g +PASS: gdb.cp/derivation.exp: whatis a_instance.a +PASS: gdb.cp/derivation.exp: ptype a_instance.a +PASS: gdb.cp/derivation.exp: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis b_instance.b +PASS: gdb.cp/derivation.exp: ptype b_instance.b +PASS: gdb.cp/derivation.exp: whatis d_instance.d +PASS: gdb.cp/derivation.exp: ptype d_instance.d +PASS: gdb.cp/derivation.exp: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis e_instance.e +PASS: gdb.cp/derivation.exp: ptype e_instance.e +PASS: gdb.cp/derivation.exp: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis f_instance.f +PASS: gdb.cp/derivation.exp: ptype f_instance.f +PASS: gdb.cp/derivation.exp: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis z_instance.z +PASS: gdb.cp/derivation.exp: ptype z_instance.z +PASS: gdb.cp/derivation.exp: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis zz_instance.zz +PASS: gdb.cp/derivation.exp: ptype zz_instance.zz +PASS: gdb.cp/derivation.exp: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: ptype vderived +PASS: gdb.cp/derivation.exp: print vderived +PASS: gdb.cp/derivation.exp: ptype N::value_type +PASS: gdb.cp/derivation.exp: ptype N::Derived::value_type +PASS: gdb.cp/derivation.exp: ptype value_type +Running ./gdb.cp/destrprint.exp ... +PASS: gdb.cp/destrprint.exp: continue to breakpoint: Break here +PASS: gdb.cp/destrprint.exp: go up to ~Derived +PASS: gdb.cp/destrprint.exp: set print object on +PASS: gdb.cp/destrprint.exp: print *this with print object = on +PASS: gdb.cp/destrprint.exp: set print object off +PASS: gdb.cp/destrprint.exp: print *this with print object = off +Running ./gdb.cp/dispcxx.exp ... +PASS: gdb.cp/dispcxx.exp: continue to breakpoint: here +PASS: gdb.cp/dispcxx.exp: display k +Running ./gdb.cp/exception.exp ... +PASS: gdb.cp/exception.exp: catch catch (before inferior run) +PASS: gdb.cp/exception.exp: catch throw (before inferior run) +PASS: gdb.cp/exception.exp: info breakpoints (before inferior run) +PASS: gdb.cp/exception.exp: Set temporary breakpoint at main +PASS: gdb.cp/exception.exp: Run to main +FAIL: gdb.cp/exception.exp: info breakpoints (after inferior run) +PASS: gdb.cp/exception.exp: break catcher +FAIL: gdb.cp/exception.exp: continue to first throw +FAIL: gdb.cp/exception.exp: backtrace after first throw +FAIL: gdb.cp/exception.exp: continue to first catch +FAIL: gdb.cp/exception.exp: backtrace after first catch +PASS: gdb.cp/exception.exp: continue to catcher for the first time +FAIL: gdb.cp/exception.exp: continue to second throw +FAIL: gdb.cp/exception.exp: backtrace after second throw +FAIL: gdb.cp/exception.exp: continue to second catch +FAIL: gdb.cp/exception.exp: backtrace after second catch +FAIL: gdb.cp/exception.exp: continue to catcher for the second time (the program is no longer running) +Running ./gdb.cp/expand-psymtabs-cxx.exp ... +PASS: gdb.cp/expand-psymtabs-cxx.exp: set language c++ +PASS: gdb.cp/expand-psymtabs-cxx.exp: before expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: force expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: after expand +Running ./gdb.cp/expand-sals.exp ... +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: func +PASS: gdb.cp/expand-sals.exp: up +PASS: gdb.cp/expand-sals.exp: break +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: caller +PASS: gdb.cp/expand-sals.exp: bt from A +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: next caller func +Running ./gdb.cp/extern-c.exp ... +PASS: gdb.cp/extern-c.exp: setting breakpoint at c_func +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_func +PASS: gdb.cp/extern-c.exp: initialize counter +PASS: gdb.cp/extern-c.exp: rbreak c_funcs +PASS: gdb.cp/extern-c.exp: command details for multiple breakpoints +PASS: gdb.cp/extern-c.exp: set commands on multiple breakpoints +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_1 +PASS: gdb.cp/extern-c.exp: verify counter at first breakpoint +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_2 +PASS: gdb.cp/extern-c.exp: verify counter at second breakpoint +Running ./gdb.cp/formatted-ref.exp ... +PASS: gdb.cp/formatted-ref.exp: print/x s +PASS: gdb.cp/formatted-ref.exp: print/x e +PASS: gdb.cp/formatted-ref.exp: print/x i +PASS: gdb.cp/formatted-ref.exp: print/x &s +PASS: gdb.cp/formatted-ref.exp: print/x &e +PASS: gdb.cp/formatted-ref.exp: print/x &i +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&s)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&i)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&e)) +PASS: gdb.cp/formatted-ref.exp: print s.x == 13 +Running ./gdb.cp/fpointer.exp ... +PASS: gdb.cp/fpointer.exp: p p1() +PASS: gdb.cp/fpointer.exp: p p2() +PASS: gdb.cp/fpointer.exp: p p[0]() +PASS: gdb.cp/fpointer.exp: p p[1]() +PASS: gdb.cp/fpointer.exp: p p3('a') +PASS: gdb.cp/fpointer.exp: p p4(1) +Running ./gdb.cp/gdb1355.exp ... +PASS: gdb.cp/gdb1355.exp: ptype s1 +PASS: gdb.cp/gdb1355.exp: print s1 +Running ./gdb.cp/gdb2384.exp ... +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +FAIL: gdb.cp/gdb2384.exp: print d1.meth () +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +FAIL: gdb.cp/gdb2384.exp: gdb2384 +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +FAIL: gdb.cp/gdb2384.exp: print d2.meth() +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +FAIL: gdb.cp/gdb2384.exp: gdb2384 (second) +Running ./gdb.cp/gdb2495.exp ... +PASS: gdb.cp/gdb2495.exp: p exceptions.no_throw_function() +PASS: gdb.cp/gdb2495.exp: p exceptions.throw_function_with_handler() +FAIL: gdb.cp/gdb2495.exp: Call a function that raises an exception without a handler. +FAIL: gdb.cp/gdb2495.exp: bt after returning from a popped frame +PASS: gdb.cp/gdb2495.exp: info breakpoints +PASS: gdb.cp/gdb2495.exp: set unwinn-on-terminating-exception off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on terminating exception flag +PASS: gdb.cp/gdb2495.exp: Call a function that raises an exception with unwinding off.. +PASS: gdb.cp/gdb2495.exp: set unwindonsignal on +PASS: gdb.cp/gdb2495.exp: Turn on unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +PASS: gdb.cp/gdb2495.exp: set unwindonsignal off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +Running ./gdb.cp/hang.exp ... +PASS: gdb.cp/hang.exp: doesn't overwrite struct type +PASS: gdb.cp/hang.exp: doesn't corrupt cv_type chain +Running ./gdb.cp/infcall-dlopen.exp ... +FAIL: gdb.cp/infcall-dlopen.exp: test 0 (GDB internal error) +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 2 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 3 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 4 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 5 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 6 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 7 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 8 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 2 +FAIL: gdb.cp/infcall-dlopen.exp: test 9 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 2 +Running ./gdb.cp/inherit.exp ... +PASS: gdb.cp/inherit.exp: set width 0 +PASS: gdb.cp/inherit.exp: set language c++ +PASS: gdb.cp/inherit.exp: ptype A (FIXME) +PASS: gdb.cp/inherit.exp: ptype class A (FIXME) +PASS: gdb.cp/inherit.exp: ptype g_A (FIXME) +PASS: gdb.cp/inherit.exp: ptype B +PASS: gdb.cp/inherit.exp: ptype class B +PASS: gdb.cp/inherit.exp: ptype g_B +PASS: gdb.cp/inherit.exp: ptype C +PASS: gdb.cp/inherit.exp: ptype class C +PASS: gdb.cp/inherit.exp: ptype g_C +PASS: gdb.cp/inherit.exp: ptype tagless struct +PASS: gdb.cp/inherit.exp: ptype variable of type tagless struct +PASS: gdb.cp/inherit.exp: ptype D +PASS: gdb.cp/inherit.exp: ptype class D +PASS: gdb.cp/inherit.exp: ptype g_D +PASS: gdb.cp/inherit.exp: ptype E +PASS: gdb.cp/inherit.exp: ptype class E +PASS: gdb.cp/inherit.exp: ptype g_E +PASS: gdb.cp/inherit.exp: ptype vA +PASS: gdb.cp/inherit.exp: ptype class vA +PASS: gdb.cp/inherit.exp: ptype g_vA +PASS: gdb.cp/inherit.exp: ptype vB +PASS: gdb.cp/inherit.exp: ptype class vB +PASS: gdb.cp/inherit.exp: ptype g_vB +PASS: gdb.cp/inherit.exp: ptype vC +PASS: gdb.cp/inherit.exp: ptype class vC +PASS: gdb.cp/inherit.exp: ptype g_vC +PASS: gdb.cp/inherit.exp: ptype vD +PASS: gdb.cp/inherit.exp: ptype class vD +PASS: gdb.cp/inherit.exp: ptype g_vD +PASS: gdb.cp/inherit.exp: ptype vE +PASS: gdb.cp/inherit.exp: ptype class vE +PASS: gdb.cp/inherit.exp: ptype g_vE +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_A.a +PASS: gdb.cp/inherit.exp: print g_A.x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_B.a +PASS: gdb.cp/inherit.exp: print g_B.b +PASS: gdb.cp/inherit.exp: print g_B.x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_C.a +PASS: gdb.cp/inherit.exp: print g_C.c +PASS: gdb.cp/inherit.exp: print g_C.x +PASS: gdb.cp/inherit.exp: print g_A +PASS: gdb.cp/inherit.exp: print g_B +PASS: gdb.cp/inherit.exp: print g_C +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_D.A::a +PASS: gdb.cp/inherit.exp: print g_D.C::a +PASS: gdb.cp/inherit.exp: print g_D.B::a +PASS: gdb.cp/inherit.exp: print g_D.A::x +PASS: gdb.cp/inherit.exp: print g_D.B::b +PASS: gdb.cp/inherit.exp: print g_D.B::x +PASS: gdb.cp/inherit.exp: print g_D.C::c +PASS: gdb.cp/inherit.exp: print g_D.C::x +PASS: gdb.cp/inherit.exp: print g_D.D::d +PASS: gdb.cp/inherit.exp: print g_D.D::x +PASS: gdb.cp/inherit.exp: print g_E.A::a +PASS: gdb.cp/inherit.exp: print g_E.A::x +PASS: gdb.cp/inherit.exp: print g_E.B::b +PASS: gdb.cp/inherit.exp: print g_E.B::x +PASS: gdb.cp/inherit.exp: print g_E.C::c +PASS: gdb.cp/inherit.exp: print g_E.C::x +PASS: gdb.cp/inherit.exp: print g_E.D::d +PASS: gdb.cp/inherit.exp: print g_E.D::x +PASS: gdb.cp/inherit.exp: print g_E.E::e +PASS: gdb.cp/inherit.exp: print g_E.E::x +PASS: gdb.cp/inherit.exp: ptype g_D.b +PASS: gdb.cp/inherit.exp: ptype g_D.c +PASS: gdb.cp/inherit.exp: ptype g_D.d +PASS: gdb.cp/inherit.exp: ptype g_A.A::a +PASS: gdb.cp/inherit.exp: ptype g_A.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.A::a +PASS: gdb.cp/inherit.exp: ptype g_B.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.B::b +PASS: gdb.cp/inherit.exp: ptype g_B.B::x +PASS: gdb.cp/inherit.exp: ptype g_C.A::a +PASS: gdb.cp/inherit.exp: ptype g_C.A::x +PASS: gdb.cp/inherit.exp: ptype g_C.C::c +PASS: gdb.cp/inherit.exp: ptype g_C.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.A::a +PASS: gdb.cp/inherit.exp: ptype g_D.A::x +PASS: gdb.cp/inherit.exp: ptype g_D.B::b +PASS: gdb.cp/inherit.exp: ptype g_D.B::x +PASS: gdb.cp/inherit.exp: ptype g_D.C::c +PASS: gdb.cp/inherit.exp: ptype g_D.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.D::d +PASS: gdb.cp/inherit.exp: ptype g_D.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.A::a +PASS: gdb.cp/inherit.exp: ptype g_E.A::x +PASS: gdb.cp/inherit.exp: ptype g_E.B::b +PASS: gdb.cp/inherit.exp: ptype g_E.B::x +PASS: gdb.cp/inherit.exp: ptype g_E.C::c +PASS: gdb.cp/inherit.exp: ptype g_E.C::x +PASS: gdb.cp/inherit.exp: ptype g_E.D::d +PASS: gdb.cp/inherit.exp: ptype g_E.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.E::e +PASS: gdb.cp/inherit.exp: ptype g_E.E::x +PASS: gdb.cp/inherit.exp: print g_D +PASS: gdb.cp/inherit.exp: print g_E +PASS: gdb.cp/inherit.exp: print anonymous union member +PASS: gdb.cp/inherit.exp: print variable of type anonymous union +PASS: gdb.cp/inherit.exp: print type of anonymous union +PASS: gdb.cp/inherit.exp: print g_vA.vA::va +PASS: gdb.cp/inherit.exp: print g_vA.vA::vx +PASS: gdb.cp/inherit.exp: print g_vA.va +PASS: gdb.cp/inherit.exp: print g_vA.vx +PASS: gdb.cp/inherit.exp: print g_vB.vA::va +PASS: gdb.cp/inherit.exp: print g_vB.vA::vx +PASS: gdb.cp/inherit.exp: print g_vB.vB::vb +PASS: gdb.cp/inherit.exp: print g_vB.vB::vx +PASS: gdb.cp/inherit.exp: print g_vB.va +PASS: gdb.cp/inherit.exp: print g_vB.vb +PASS: gdb.cp/inherit.exp: print g_vB.vx +PASS: gdb.cp/inherit.exp: print g_vC.vA::va +PASS: gdb.cp/inherit.exp: print g_vC.vA::vx +PASS: gdb.cp/inherit.exp: print g_vC.vC::vc +PASS: gdb.cp/inherit.exp: print g_vC.vC::vx +PASS: gdb.cp/inherit.exp: print g_vC.va +PASS: gdb.cp/inherit.exp: print g_vC.vc +PASS: gdb.cp/inherit.exp: print g_vC.vx +PASS: gdb.cp/inherit.exp: print g_vA +PASS: gdb.cp/inherit.exp: print g_vB (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vC (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vD.vA::va +PASS: gdb.cp/inherit.exp: print g_vD.vA::vx +PASS: gdb.cp/inherit.exp: print g_vD.vB::vb +PASS: gdb.cp/inherit.exp: print g_vD.vB::vx +PASS: gdb.cp/inherit.exp: print g_vD.vC::vc +PASS: gdb.cp/inherit.exp: print g_vD.vC::vx +PASS: gdb.cp/inherit.exp: print g_vD.vD::vd +PASS: gdb.cp/inherit.exp: print g_vD.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vA::va +PASS: gdb.cp/inherit.exp: print g_vE.vA::vx +PASS: gdb.cp/inherit.exp: print g_vE.vB::vb +PASS: gdb.cp/inherit.exp: print g_vE.vB::vx +PASS: gdb.cp/inherit.exp: print g_vE.vC::vc +PASS: gdb.cp/inherit.exp: print g_vE.vC::vx +PASS: gdb.cp/inherit.exp: print g_vE.vD::vd +PASS: gdb.cp/inherit.exp: print g_vE.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vE::ve +PASS: gdb.cp/inherit.exp: print g_vE.vE::vx +PASS: gdb.cp/inherit.exp: print g_vD (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vE (FIXME v3 vtbl ptr) +Running ./gdb.cp/koenig.exp ... +PASS: gdb.cp/koenig.exp: p first(c) +PASS: gdb.cp/koenig.exp: p second(0,0,c,0,0) +PASS: gdb.cp/koenig.exp: p entry (c) +PASS: gdb.cp/koenig.exp: p first(0,c) +PASS: gdb.cp/koenig.exp: p first(b.c) +PASS: gdb.cp/koenig.exp: p foo(eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo, 1) +PASS: gdb.cp/koenig.exp: p foo(fo, eo) +PASS: gdb.cp/koenig.exp: p foo(1 ,fo, eo) +PASS: gdb.cp/koenig.exp: p foo(go, fo, eo) +PASS: gdb.cp/koenig.exp: p fake(eo) +PASS: gdb.cp/koenig.exp: p foo (fake) +PASS: gdb.cp/koenig.exp: p foo(io) +PASS: gdb.cp/koenig.exp: p foo(ix) +PASS: gdb.cp/koenig.exp: p foo(ju) +PASS: gdb.cp/koenig.exp: p foo(js) +PASS: gdb.cp/koenig.exp: p foo(je) +XFAIL: gdb.cp/koenig.exp: p foo(jab) +PASS: gdb.cp/koenig.exp: p foo(jap) +PASS: gdb.cp/koenig.exp: p foo(japp) +PASS: gdb.cp/koenig.exp: p foo(jca) +PASS: gdb.cp/koenig.exp: p foo(ko,1) +PASS: gdb.cp/koenig.exp: p foo(ko,1.0f) +XFAIL: gdb.cp/koenig.exp: p bar(ko,1) +PASS: gdb.cp/koenig.exp: p foo(labo) +PASS: gdb.cp/koenig.exp: p ma.foo('a') +PASS: gdb.cp/koenig.exp: p foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::FAKE::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::fake(ma,'a') +PASS: gdb.cp/koenig.exp: p M::bar('a') +PASS: gdb.cp/koenig.exp: p M::N::bar('a') +PASS: gdb.cp/koenig.exp: p foo(ttoa, 'a') +PASS: gdb.cp/koenig.exp: p foo (p_union) +PASS: gdb.cp/koenig.exp: p q == 5 +PASS: gdb.cp/koenig.exp: p q == 5.0f +PASS: gdb.cp/koenig.exp: p q != 5 +PASS: gdb.cp/koenig.exp: p q != 5.0f +PASS: gdb.cp/koenig.exp: p q + 5.0f +PASS: gdb.cp/koenig.exp: p q + 5 +PASS: gdb.cp/koenig.exp: p ++q +PASS: gdb.cp/koenig.exp: p r.rfoo() +PASS: gdb.cp/koenig.exp: continue to breakpoint: marker1 +PASS: gdb.cp/koenig.exp: p rfoo() +PASS: gdb.cp/koenig.exp: p this->rfoo() +Running ./gdb.cp/local.exp ... +PASS: gdb.cp/local.exp: up from marker1 +PASS: gdb.cp/local.exp: ptype l +PASS: gdb.cp/local.exp: ptype Local +PASS: gdb.cp/local.exp: break marker2 +PASS: gdb.cp/local.exp: continuing to marker2 +PASS: gdb.cp/local.exp: up from marker2 +PASS: gdb.cp/local.exp: Local out of scope +PASS: gdb.cp/local.exp: ptype InnerLocal (pattern 1) +PASS: gdb.cp/local.exp: ptype NestedInnerLocal +KFAIL: gdb.cp/local.exp: ptype InnerLocal::NestedInnerLocal (PRMS: gdb/482) +Running ./gdb.cp/maint.exp ... +PASS: gdb.cp/maint.exp: help maintenance cplus +PASS: gdb.cp/maint.exp: help maint cp +PASS: gdb.cp/maint.exp: maint cp +PASS: gdb.cp/maint.exp: help maint cp first_component +PASS: gdb.cp/maint.exp: help maint cp namespace +PASS: gdb.cp/maint.exp: set complaints 1000 +PASS: gdb.cp/maint.exp: maint cp first_component foo +PASS: gdb.cp/maint.exp: maint cp first_component operator<< +PASS: gdb.cp/maint.exp: maint cp first_component operator>> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator() +PASS: gdb.cp/maint.exp: maint cp first_component operator> +PASS: gdb.cp/maint.exp: maint cp first_component operator< +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component foo() +PASS: gdb.cp/maint.exp: maint cp first_component foo(int) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y, A::B) +PASS: gdb.cp/maint.exp: maint cp first_component foo(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >) +PASS: gdb.cp/maint.exp: maint cp first_component operator>(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component int operator<< <char>() +PASS: gdb.cp/maint.exp: maint cp first_component T<Cooperator> +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&(operator<<(C, C))>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar::baz +PASS: gdb.cp/maint.exp: maint cp first_component C<A>::bar +PASS: gdb.cp/maint.exp: maint cp first_component C<std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > >::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo< +PASS: gdb.cp/maint.exp: maint cp first_component foo( +PASS: gdb.cp/maint.exp: maint cp first_component bool operator<<char> +PASS: gdb.cp/maint.exp: maint cp namespace +Running ./gdb.cp/mb-ctor.exp ... +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at ctor +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at dtor +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v1 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v2 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v1 +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v2 +PASS: gdb.cp/mb-ctor.exp: run to exit +Running ./gdb.cp/mb-inline.exp ... +PASS: gdb.cp/mb-inline.exp: set breakpoint +PASS: gdb.cp/mb-inline.exp: info break +PASS: gdb.cp/mb-inline.exp: run to breakpoint +PASS: gdb.cp/mb-inline.exp: run to breakpoint 2 +PASS: gdb.cp/mb-inline.exp: disabling location: disable +PASS: gdb.cp/mb-inline.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-inline.exp: disabled breakpoint 1.2 +PASS: gdb.cp/mb-inline.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 afn +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 bfn +Running ./gdb.cp/mb-templates.exp ... +PASS: gdb.cp/mb-templates.exp: initial condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: kill +PASS: gdb.cp/mb-templates.exp: separate condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: set condition +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: disabling location: disable +PASS: gdb.cp/mb-templates.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-templates.exp: disabling location: enable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: disable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: set breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <int> +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <double> +Running ./gdb.cp/m-data.exp ... +PASS: gdb.cp/m-data.exp: continue to breakpoint: end of first constructors +PASS: gdb.cp/m-data.exp: simple object, const bool +PASS: gdb.cp/m-data.exp: simple object, const int +PASS: gdb.cp/m-data.exp: simple object, long +PASS: gdb.cp/m-data.exp: simple object, enum +PASS: gdb.cp/m-data.exp: derived template object, base const bool +PASS: gdb.cp/m-data.exp: derived template object, base const int +PASS: gdb.cp/m-data.exp: derived template object, base long +PASS: gdb.cp/m-data.exp: derived template object, base enum +PASS: gdb.cp/m-data.exp: derived template object, derived enum +PASS: gdb.cp/m-data.exp: template object, const bool +PASS: gdb.cp/m-data.exp: template object, const int +PASS: gdb.cp/m-data.exp: template object, long +PASS: gdb.cp/m-data.exp: template object, base enum +PASS: gdb.cp/m-data.exp: template object, derived enum +PASS: gdb.cp/m-data.exp: continue to breakpoint: continue to shadow breakpoint +PASS: gdb.cp/m-data.exp: shadowing member +PASS: gdb.cp/m-data.exp: shadowed global variable +Running ./gdb.cp/member-name.exp ... +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to first breakpoint +PASS: gdb.cp/member-name.exp: print C::x from first breakpoint +PASS: gdb.cp/member-name.exp: print B::b from first breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from first breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to second breakpoint +PASS: gdb.cp/member-name.exp: print C::x from second breakpoint +PASS: gdb.cp/member-name.exp: print B::b from second breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from second breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to third breakpoint +PASS: gdb.cp/member-name.exp: print Templ::y from third breakpoint +Running ./gdb.cp/member-ptr.exp ... +PASS: gdb.cp/member-ptr.exp: continue to breakpoint: continue to pmi = NULL +PASS: gdb.cp/member-ptr.exp: ptype pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::jj +PASS: gdb.cp/member-ptr.exp: print pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (again) +PASS: gdb.cp/member-ptr.exp: print a.*pmi = 33 +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (33) +PASS: gdb.cp/member-ptr.exp: print a (j = 33) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi = 44 +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (44) +PASS: gdb.cp/member-ptr.exp: print a (j = 44) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmi +PASS: gdb.cp/member-ptr.exp: print *pmi +PASS: gdb.cp/member-ptr.exp: ptype *pmi +PASS: gdb.cp/member-ptr.exp: print (int) pmi +PASS: gdb.cp/member-ptr.exp: print ((int) pmi) == ((char *) &a.j - (char *) &a) +PASS: gdb.cp/member-ptr.exp: ptype diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: ptype diamond.*diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pfunc_ptr (20) +PASS: gdb.cp/member-ptr.exp: print (diamond.*diamond_pfunc_ptr) (20) +PASS: gdb.cp/member-ptr.exp: print diamond.func_ptr (20) +PASS: gdb.cp/member-ptr.exp: ptype pmf +PASS: gdb.cp/member-ptr.exp: print pmf +PASS: gdb.cp/member-ptr.exp: ptype pmf_p +PASS: gdb.cp/member-ptr.exp: gdb/NNNN +PASS: gdb.cp/member-ptr.exp: print a.*pmf +PASS: gdb.cp/member-ptr.exp: print a_p->*pmf +PASS: gdb.cp/member-ptr.exp: set var pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print *pmf +PASS: gdb.cp/member-ptr.exp: ptype *pmf +PASS: gdb.cp/member-ptr.exp: print (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmf +PASS: gdb.cp/member-ptr.exp: ptype (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: print diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*left_pmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_pmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_pmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_pmf) () +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_vpmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_base_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_vpmf) () +PASS: gdb.cp/member-ptr.exp: print left_vpmf +PASS: gdb.cp/member-ptr.exp: print right_vpmf +PASS: gdb.cp/member-ptr.exp: print base_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf () +PASS: gdb.cp/member-ptr.exp: print null_pmi +PASS: gdb.cp/member-ptr.exp: print null_pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print null_pmi = 0 +PASS: gdb.cp/member-ptr.exp: print null_pmf +PASS: gdb.cp/member-ptr.exp: print null_pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print null_pmf = 0 +Running ./gdb.cp/method2.exp ... +PASS: gdb.cp/method2.exp: set multiple-symbols ask +PASS: gdb.cp/method2.exp: setting language c +PASS: gdb.cp/method2.exp: breaking in method (c) +PASS: gdb.cp/method2.exp: setting language c++ +PASS: gdb.cp/method2.exp: breaking in method (c++) +FAIL: gdb.cp/method2.exp: setting breakpoint at exit +Running ./gdb.cp/method.exp ... +PASS: gdb.cp/method.exp: break A::foo +PASS: gdb.cp/method.exp: continue to A::foo +PASS: gdb.cp/method.exp: print x in A::foo +PASS: gdb.cp/method.exp: print this in A::foo +PASS: gdb.cp/method.exp: break A::bar +PASS: gdb.cp/method.exp: continue to A::bar +PASS: gdb.cp/method.exp: print x in A::bar +PASS: gdb.cp/method.exp: print this in A::bar +PASS: gdb.cp/method.exp: break 21 +PASS: gdb.cp/method.exp: continue to 21 +PASS: gdb.cp/method.exp: print data_ in funk::getFunky +PASS: gdb.cp/method.exp: print this in funk::getFunky +PASS: gdb.cp/method.exp: print res in funk::getFunky +PASS: gdb.cp/method.exp: ptype A +PASS: gdb.cp/method.exp: finish program +Running ./gdb.cp/meth-typedefs.exp ... +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: break test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::c::d::bar&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::c::d::bar&)' +Running ./gdb.cp/minsym-fallback.exp ... +PASS: gdb.cp/minsym-fallback.exp: set breakpoint pending off +PASS: gdb.cp/minsym-fallback.exp: break C::f() +PASS: gdb.cp/minsym-fallback.exp: break C::operator()() +Running ./gdb.cp/misc.exp ... +PASS: gdb.cp/misc.exp: deduced language is C++, before full symbols +PASS: gdb.cp/misc.exp: deduced language is C++, after full symbols +PASS: gdb.cp/misc.exp: print s.a for foo struct (known gcc 2.7.2 and earlier bug) +PASS: gdb.cp/misc.exp: print as bool (setup) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 1) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 2) +PASS: gdb.cp/misc.exp: print a bool var +PASS: gdb.cp/misc.exp: set a bool var (setup) +PASS: gdb.cp/misc.exp: set a bool var (print v_bool) +PASS: gdb.cp/misc.exp: print a bool array +PASS: gdb.cp/misc.exp: set a bool array elem (setup) +PASS: gdb.cp/misc.exp: set a bool array elem (print v_bool_array) +PASS: gdb.cp/misc.exp: print true +PASS: gdb.cp/misc.exp: print false +PASS: gdb.cp/misc.exp: 1 + true +PASS: gdb.cp/misc.exp: 3 + false +PASS: gdb.cp/misc.exp: 1 < 2 < 3 +PASS: gdb.cp/misc.exp: 2 < 1 > 4 +PASS: gdb.cp/misc.exp: (bool)43 +PASS: gdb.cp/misc.exp: (bool)0 +PASS: gdb.cp/misc.exp: (bool)17.93 +PASS: gdb.cp/misc.exp: (bool)0.0 +PASS: gdb.cp/misc.exp: (int)true +PASS: gdb.cp/misc.exp: (int)false +Running ./gdb.cp/m-static.exp ... +PASS: gdb.cp/m-static.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/m-static.exp: simple object, static const int, accessing via 'class::method::variable +PASS: gdb.cp/m-static.exp: simple object, static const bool +PASS: gdb.cp/m-static.exp: simple object, static const int +PASS: gdb.cp/m-static.exp: simple object, static long +PASS: gdb.cp/m-static.exp: simple object, static enum +FAIL: gdb.cp/m-static.exp: simple object instance, print quoted destructor +FAIL: gdb.cp/m-static.exp: simple object class, ptype quoted destructor +PASS: gdb.cp/m-static.exp: derived template object, base static const bool +PASS: gdb.cp/m-static.exp: derived template object, base static const int +PASS: gdb.cp/m-static.exp: derived template object, base static long +PASS: gdb.cp/m-static.exp: derived template object, base static enum +PASS: gdb.cp/m-static.exp: derived template object, static enum +PASS: gdb.cp/m-static.exp: template object, static const bool +PASS: gdb.cp/m-static.exp: template object, static const int +PASS: gdb.cp/m-static.exp: template object, static long +PASS: gdb.cp/m-static.exp: template object, static enum +PASS: gdb.cp/m-static.exp: template object, static derived enum +PASS: gdb.cp/m-static.exp: static const int initialized elsewhere +PASS: gdb.cp/m-static.exp: static const int initialized nowhere +PASS: gdb.cp/m-static.exp: static const int initialized in class definition +PASS: gdb.cp/m-static.exp: static const float initialized in class definition +PASS: gdb.cp/m-static.exp: info variable everywhere +PASS: gdb.cp/m-static.exp: step +FAIL: gdb.cp/m-static.exp: print svar +Running ./gdb.cp/namespace-enum.exp ... +PASS: gdb.cp/namespace-enum.exp: print foo::B::B_B +PASS: gdb.cp/namespace-enum.exp: print foo::B_B +PASS: gdb.cp/namespace-enum.exp: print A_A +Running ./gdb.cp/namespace.exp ... +PASS: gdb.cp/namespace.exp: show lang +PASS: gdb.cp/namespace.exp: up from marker1 +PASS: gdb.cp/namespace.exp: print 'AAA::c' +PASS: gdb.cp/namespace.exp: print AAA::c +PASS: gdb.cp/namespace.exp: print ina +PASS: gdb.cp/namespace.exp: ptype ina +PASS: gdb.cp/namespace.exp: info func xyzq +PASS: gdb.cp/namespace.exp: print 'AAA::xyzq'('x') +PASS: gdb.cp/namespace.exp: print AAA::xyzq('x') +PASS: gdb.cp/namespace.exp: break AAA::xyzq +PASS: gdb.cp/namespace.exp: break ::ensureOtherRefs +PASS: gdb.cp/namespace.exp: print 'BBB::CCC::xyzq'('x') +PASS: gdb.cp/namespace.exp: print BBB::CCC::xyzq('x') +PASS: gdb.cp/namespace.exp: break BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: break ::BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: print 'BBB::Class::xyzq' +PASS: gdb.cp/namespace.exp: print BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: break BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: whatis ::C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: print C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print c +PASS: gdb.cp/namespace.exp: print cc +PASS: gdb.cp/namespace.exp: print 'C::cc' +PASS: gdb.cp/namespace.exp: print C::cc +PASS: gdb.cp/namespace.exp: print cd +PASS: gdb.cp/namespace.exp: print C::D::cd +PASS: gdb.cp/namespace.exp: print 'E::cde' +PASS: gdb.cp/namespace.exp: print E::cde +PASS: gdb.cp/namespace.exp: print shadow +PASS: gdb.cp/namespace.exp: print E::ce +PASS: gdb.cp/namespace.exp: ptype C +PASS: gdb.cp/namespace.exp: ptype E +PASS: gdb.cp/namespace.exp: ptype CClass +PASS: gdb.cp/namespace.exp: ptype CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::CClass +PASS: gdb.cp/namespace.exp: ptype C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::NestedClass +PASS: gdb.cp/namespace.exp: print cOtherFile +PASS: gdb.cp/namespace.exp: ptype OtherFileClass +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: print cX +PASS: gdb.cp/namespace.exp: print 'F::cXf' +PASS: gdb.cp/namespace.exp: print F::cXf +PASS: gdb.cp/namespace.exp: print F::cXfX +PASS: gdb.cp/namespace.exp: print X +PASS: gdb.cp/namespace.exp: print 'G::Xg' +PASS: gdb.cp/namespace.exp: print G::Xg +PASS: gdb.cp/namespace.exp: print G::XgX +PASS: gdb.cp/namespace.exp: print cXOtherFile +PASS: gdb.cp/namespace.exp: print XOtherFile +PASS: gdb.cp/namespace.exp: print AAA::ALPHA +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass * +Running ./gdb.cp/namespace-nested-import.exp ... +PASS: gdb.cp/namespace-nested-import.exp: print C::x +Running ./gdb.cp/nextoverthrow.exp ... +UNSUPPORTED: gdb.cp/nextoverthrow.exp: nextoverthrow.exp could not find _Unwind_DebugHook +Running ./gdb.cp/no-dmgl-verbose.exp ... +PASS: gdb.cp/no-dmgl-verbose.exp: set breakpoint pending off +PASS: gdb.cp/no-dmgl-verbose.exp: DMGL_VERBOSE-demangled f(std::string) is not defined +Running ./gdb.cp/noparam.exp ... +PASS: gdb.cp/noparam.exp: p C::m (int) +Running ./gdb.cp/nsdecl.exp ... +PASS: gdb.cp/nsdecl.exp: print fakex +Running ./gdb.cp/nsimport.exp ... +PASS: gdb.cp/nsimport.exp: print x +PASS: gdb.cp/nsimport.exp: print xx +PASS: gdb.cp/nsimport.exp: print xxx +Running ./gdb.cp/nsnested.exp ... +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::first +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: print C::D::ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::D::second +PASS: gdb.cp/nsnested.exp: print ab +Running ./gdb.cp/nsnoimports.exp ... +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::first +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print C::abc +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::C::second +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +Running ./gdb.cp/nsrecurs.exp ... +PASS: gdb.cp/nsrecurs.exp: print ax +PASS: gdb.cp/nsrecurs.exp: print dx +PASS: gdb.cp/nsrecurs.exp: print xx +KFAIL: gdb.cp/nsrecurs.exp: ptype G::GF (PRMS: gdb/10541) +KFAIL: gdb.cp/nsrecurs.exp: print G::GF::FE::ex (PRMS: gdb/10541) +Running ./gdb.cp/nsstress.exp ... +PASS: gdb.cp/nsstress.exp: print y +Running ./gdb.cp/nsusing.exp ... +PASS: gdb.cp/nsusing.exp: print _a +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker3 +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker1 stop +PASS: gdb.cp/nsusing.exp: print _a in a nested scope +PASS: gdb.cp/nsusing.exp: print cc +PASS: gdb.cp/nsusing.exp: print B::_a +PASS: gdb.cp/nsusing.exp: print _a in namespace alias scope +PASS: gdb.cp/nsusing.exp: print x in namespace alias scope +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: print dx +PASS: gdb.cp/nsusing.exp: print efx +PASS: gdb.cp/nsusing.exp: print ghx +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: K::marker9 +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker10 stop +PASS: gdb.cp/nsusing.exp: print x (from M::x) +Running ./gdb.cp/operator.exp ... +PASS: gdb.cp/operator.exp: global operator +PASS: gdb.cp/operator.exp: global operator overload +PASS: gdb.cp/operator.exp: ADL operator +PASS: gdb.cp/operator.exp: ADL operator overload +PASS: gdb.cp/operator.exp: Fully qualified explicit operator call +PASS: gdb.cp/operator.exp: anonymous namespace operator +PASS: gdb.cp/operator.exp: anonymous namespace operator overload +PASS: gdb.cp/operator.exp: anonymous namespace operator overload float +PASS: gdb.cp/operator.exp: imported operator +PASS: gdb.cp/operator.exp: imported operator overload +PASS: gdb.cp/operator.exp: imported operator overload float +PASS: gdb.cp/operator.exp: member operator +PASS: gdb.cp/operator.exp: member operator overload +PASS: gdb.cp/operator.exp: namespace alias +PASS: gdb.cp/operator.exp: imported declaration +PASS: gdb.cp/operator.exp: p l == 1 +PASS: gdb.cp/operator.exp: p x[0] +Running ./gdb.cp/oranking.exp ... +PASS: gdb.cp/oranking.exp: continue to breakpoint: end of main +KFAIL: gdb.cp/oranking.exp: p foo0(b) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test1() +PASS: gdb.cp/oranking.exp: p foo1(b) +PASS: gdb.cp/oranking.exp: p test2() +KFAIL: gdb.cp/oranking.exp: p foo2(b) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test3() +PASS: gdb.cp/oranking.exp: p foo3(1.0f) +PASS: gdb.cp/oranking.exp: p test4() +KFAIL: gdb.cp/oranking.exp: p foo4(&a) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test5() +PASS: gdb.cp/oranking.exp: p foo5(c) +PASS: gdb.cp/oranking.exp: p test6() +PASS: gdb.cp/oranking.exp: p foo6(bp) +PASS: gdb.cp/oranking.exp: p test7() +PASS: gdb.cp/oranking.exp: p foo7(cp) +PASS: gdb.cp/oranking.exp: p test8() +PASS: gdb.cp/oranking.exp: p foo8(co) +PASS: gdb.cp/oranking.exp: p test9() +PASS: gdb.cp/oranking.exp: p foo9(co) +PASS: gdb.cp/oranking.exp: p test10() +KFAIL: gdb.cp/oranking.exp: p foo10(amp) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test101() +KFAIL: gdb.cp/oranking.exp: p foo101("abc") (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test11() +KFAIL: gdb.cp/oranking.exp: p foo11(d) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test12() +PASS: gdb.cp/oranking.exp: p foo12(1) +PASS: gdb.cp/oranking.exp: p test13() +KFAIL: gdb.cp/oranking.exp: p foo13(c) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test14() +KFAIL: gdb.cp/oranking.exp: p foo14(e) (PRMS: gdb/12096) +Running ./gdb.cp/overload-const.exp ... +PASS: gdb.cp/overload-const.exp: set language c++ +PASS: gdb.cp/overload-const.exp: setting breakpoint at myclass::func +Running ./gdb.cp/overload.exp ... +PASS: gdb.cp/overload.exp: up from marker1 +PASS: gdb.cp/overload.exp: print foo_instance1 +PASS: gdb.cp/overload.exp: ptype foo_instance1 (shorter match) +PASS: gdb.cp/overload.exp: print foo_instance2 +PASS: gdb.cp/overload.exp: print foo_instance3 +PASS: gdb.cp/overload.exp: print call overloaded func 1 arg +PASS: gdb.cp/overload.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/overload.exp: print call overloaded func 2 args +PASS: gdb.cp/overload.exp: print call overloaded func 3 args +PASS: gdb.cp/overload.exp: print call overloaded func 4 args +PASS: gdb.cp/overload.exp: print call overloaded func 5 args +PASS: gdb.cp/overload.exp: print call overloaded func 6 args +PASS: gdb.cp/overload.exp: print call overloaded func 7 args +PASS: gdb.cp/overload.exp: print call overloaded func 8 args +PASS: gdb.cp/overload.exp: print call overloaded func 9 args +PASS: gdb.cp/overload.exp: print call overloaded func 10 args +PASS: gdb.cp/overload.exp: print call overloaded func 11 args +PASS: gdb.cp/overload.exp: print call overloaded func void arg +PASS: gdb.cp/overload.exp: print call overloaded func char arg +PASS: gdb.cp/overload.exp: print call overloaded func signed char arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned char arg +PASS: gdb.cp/overload.exp: print call overloaded func short arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned short arg +PASS: gdb.cp/overload.exp: print call overloaded func int arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned int arg +PASS: gdb.cp/overload.exp: print call overloaded func long arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned long arg +PASS: gdb.cp/overload.exp: print call overloaded func float arg +PASS: gdb.cp/overload.exp: print call overloaded func double arg +PASS: gdb.cp/overload.exp: print call overloaded func int\* arg +PASS: gdb.cp/overload.exp: print call overloaded func char\* arg +PASS: gdb.cp/overload.exp: print bar(a) +PASS: gdb.cp/overload.exp: print bar(b) +PASS: gdb.cp/overload.exp: print bar(c) +PASS: gdb.cp/overload.exp: print bar(d) +PASS: gdb.cp/overload.exp: list overloaded function with no args +PASS: gdb.cp/overload.exp: list overloaded function with int arg +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args - quotes around argument +PASS: gdb.cp/overload.exp: list overload.cc:intToChar +PASS: gdb.cp/overload.exp: list overload.cc:intToChar(char) +PASS: gdb.cp/overload.exp: list overload.cc:'intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc:intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc':intToChar(char) +PASS: gdb.cp/overload.exp: list 'overload.cc':'intToChar(char)' +PASS: gdb.cp/overload.exp: list overload.cc:foo::overloadfnarg(int) +PASS: gdb.cp/overload.exp: list overload.cc:'foo::overloadfnarg(int)' +PASS: gdb.cp/overload.exp: print overloadNamespace(1) +PASS: gdb.cp/overload.exp: print overloadNamespace('a') +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) +PASS: gdb.cp/overload.exp: print K::staticoverload () +PASS: gdb.cp/overload.exp: print K::staticoverload (2) +PASS: gdb.cp/overload.exp: print K::staticoverload (2, 3) +PASS: gdb.cp/overload.exp: print N::nsoverload () +PASS: gdb.cp/overload.exp: print N::nsoverload (2) +PASS: gdb.cp/overload.exp: print N::nsoverload (2, 3) +PASS: gdb.cp/overload.exp: print overloadNamespace(1) in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace('a') in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) in XXX +PASS: gdb.cp/overload.exp: print intToChar(1) +PASS: gdb.cp/overload.exp: print foo::overload1arg +PASS: gdb.cp/overload.exp: print foo::overload1arg(char***) +PASS: gdb.cp/overload.exp: print foo::overload1arg(void) +PASS: gdb.cp/overload.exp: print foo::overload1arg(char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(signed char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(float) +PASS: gdb.cp/overload.exp: print foo::overload1arg(double) +Running ./gdb.cp/ovldbreak.exp ... +PASS: gdb.cp/ovldbreak.exp: detect void +PASS: gdb.cp/ovldbreak.exp: detect char +PASS: gdb.cp/ovldbreak.exp: detect signed_char +PASS: gdb.cp/ovldbreak.exp: detect unsigned_char +PASS: gdb.cp/ovldbreak.exp: detect short_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: detect int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_int +PASS: gdb.cp/ovldbreak.exp: detect long_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: detect float +PASS: gdb.cp/ovldbreak.exp: detect double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols ask +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 2 +PASS: gdb.cp/ovldbreak.exp: set bp 2 on foo::overload1arg 2 line 107 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 3 +PASS: gdb.cp/ovldbreak.exp: set bp 3 on foo::overload1arg 3 line 110 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 4 +PASS: gdb.cp/ovldbreak.exp: set bp 4 on foo::overload1arg 4 line 140 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 5 +PASS: gdb.cp/ovldbreak.exp: set bp 5 on foo::overload1arg 5 line 137 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 6 +PASS: gdb.cp/ovldbreak.exp: set bp 6 on foo::overload1arg 6 line 125 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 7 +PASS: gdb.cp/ovldbreak.exp: set bp 7 on foo::overload1arg 7 line 131 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 8 +PASS: gdb.cp/ovldbreak.exp: set bp 8 on foo::overload1arg 8 line 119 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 9 +PASS: gdb.cp/ovldbreak.exp: set bp 9 on foo::overload1arg 9 line 113 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 10 +PASS: gdb.cp/ovldbreak.exp: set bp 10 on foo::overload1arg 10 line 116 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 11 +PASS: gdb.cp/ovldbreak.exp: set bp 11 on foo::overload1arg 11 line 128 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 12 +PASS: gdb.cp/ovldbreak.exp: set bp 12 on foo::overload1arg 12 line 134 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 13 +PASS: gdb.cp/ovldbreak.exp: set bp 13 on foo::overload1arg 13 line 122 +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting one-by-one) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice cancel +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg canceled +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after cancel) +PASS: gdb.cp/ovldbreak.exp: delete all breakpoints +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after delete) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice all +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg all +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting on all) +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : void +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : signed_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : float +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols cancel +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols all +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +FAIL: gdb.cp/ovldbreak.exp: setting breakpoint at exit +Running ./gdb.cp/ovsrch.exp ... +PASS: gdb.cp/ovsrch.exp: break A::stop_here +PASS: gdb.cp/ovsrch.exp: break 'A::stop_here' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::hibob if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::stop_here_too +PASS: gdb.cp/ovsrch.exp: break 'A::B::stop_here_too' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here_too +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::hibob if (a_param == 3) +Running ./gdb.cp/paren-type.exp ... +PASS: gdb.cp/paren-type.exp: set breakpoint pending off +PASS: gdb.cp/paren-type.exp: break C::f(long) +PASS: gdb.cp/paren-type.exp: break C::f(short) +Running ./gdb.cp/parse-lang.exp ... +PASS: gdb.cp/parse-lang.exp: breakpoint hit +Running ./gdb.cp/pass-by-ref.exp ... +PASS: gdb.cp/pass-by-ref.exp: call function in obj +PASS: gdb.cp/pass-by-ref.exp: call function in derived +PASS: gdb.cp/pass-by-ref.exp: call function in container +Running ./gdb.cp/pr-1023.exp ... +PASS: gdb.cp/pr-1023.exp: break myClass::performBlocking +PASS: gdb.cp/pr-1023.exp: break myClass::performUnblocking +Running ./gdb.cp/pr10687.exp ... +PASS: gdb.cp/pr10687.exp: continue to breakpoint: marker +PASS: gdb.cp/pr10687.exp: p a +Running ./gdb.cp/pr10728.exp ... +PASS: gdb.cp/pr10728.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/pr10728.exp: print x->y2 - x->y1 +Running ./gdb.cp/pr12028.exp ... +PASS: gdb.cp/pr12028.exp: p D::foo(b) +Running ./gdb.cp/pr-1210.exp ... +PASS: gdb.cp/pr-1210.exp: step past initialization +PASS: gdb.cp/pr-1210.exp: print *obj +PASS: gdb.cp/pr-1210.exp: print obj->myB +Running ./gdb.cp/pr-574.exp ... +PASS: gdb.cp/pr-574.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/pr-574.exp: PR gdb/574 +Running ./gdb.cp/pr9067.exp ... +PASS: gdb.cp/pr9067.exp: print b +Running ./gdb.cp/pr9167.exp ... +PASS: gdb.cp/pr9167.exp: continue to breakpoint: marker +PASS: gdb.cp/pr9167.exp: p b +Running ./gdb.cp/pr9631.exp ... +PASS: gdb.cp/pr9631.exp: continue to breakpoint: after bar tender is initialized +PASS: gdb.cp/pr9631.exp: print tender +Running ./gdb.cp/printmethod.exp ... +PASS: gdb.cp/printmethod.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/printmethod.exp: print virtual method. +PASS: gdb.cp/printmethod.exp: print nonvirtual method. +Running ./gdb.cp/psmang.exp ... +PASS: gdb.cp/psmang.exp: break s::method1 +PASS: gdb.cp/psmang.exp: break s::method2 +Running ./gdb.cp/psymtab-parameter.exp ... +PASS: gdb.cp/psymtab-parameter.exp: set language c++ +PASS: gdb.cp/psymtab-parameter.exp: maintenance info symtabs +PASS: gdb.cp/psymtab-parameter.exp: complete p 'func<short>( +Running ./gdb.cp/ptype-cv-cp.exp ... +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_const_my_int +Running ./gdb.cp/ptype-flags.exp ... +PASS: gdb.cp/ptype-flags.exp: basic test +PASS: gdb.cp/ptype-flags.exp: no methods +PASS: gdb.cp/ptype-flags.exp: no typedefs +PASS: gdb.cp/ptype-flags.exp: no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: raw +PASS: gdb.cp/ptype-flags.exp: raw no methods +PASS: gdb.cp/ptype-flags.exp: raw no typedefs +PASS: gdb.cp/ptype-flags.exp: raw no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: set print type methods off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, default methods off +PASS: gdb.cp/ptype-flags.exp: no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: set print type typedefs off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: typedefs, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods typedefs, default methods+typedefs off +Running ./gdb.cp/punctuator.exp ... +PASS: gdb.cp/punctuator.exp: set lang c++ +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitand 0xaaaa) == (0x5a5a & 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitor 0xaaaa) == (0x5a5a | 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a xor 0xaaaa) == (0x5a5a ^ 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a and 0xaaaa) == (0x5a5a && 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a or 0xaaaa) == (0x5a5a || 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (not not 0xaaaa) == (!!0xaaaa) +PASS: gdb.cp/punctuator.exp: print (compl 0xaaaa) == (~0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 1 +PASS: gdb.cp/punctuator.exp: set $v 1 +PASS: gdb.cp/punctuator.exp: print ($u not_eq 0xaaaa) == ($v != 0xaaaa) +PASS: gdb.cp/punctuator.exp: print ($u and_eq 0xaaaa) == ($v &= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 2 +PASS: gdb.cp/punctuator.exp: set $v 2 +PASS: gdb.cp/punctuator.exp: print ($u or_eq 0xaaaa) == ($v |= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 3 +PASS: gdb.cp/punctuator.exp: set $v 3 +PASS: gdb.cp/punctuator.exp: print ($u xor_eq 0xaaaa) == ($v ^= 0xaaaa) +Running ./gdb.cp/readnow-language.exp ... +PASS: gdb.cp/readnow-language.exp: show language +Running ./gdb.cp/ref-params.exp ... +PASS: gdb.cp/ref-params.exp: print value of a Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f2 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of f2 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of f1 on Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of Parent& in f1 +PASS: gdb.cp/ref-params.exp: print f1(MQ) +PASS: gdb.cp/ref-params.exp: print mf1(MQ) +PASS: gdb.cp/ref-params.exp: print mf2(MQ) +PASS: gdb.cp/ref-params.exp: print f1(MQR) +PASS: gdb.cp/ref-params.exp: print mf1(MQR) +PASS: gdb.cp/ref-params.exp: print mf2(MQR) +Running ./gdb.cp/ref-types.exp ... +PASS: gdb.cp/ref-types.exp: up from marker1 1 +PASS: gdb.cp/ref-types.exp: print value of s +PASS: gdb.cp/ref-types.exp: ptype s +PASS: gdb.cp/ref-types.exp: print value of ps +PASS: gdb.cp/ref-types.exp: ptype ps +PASS: gdb.cp/ref-types.exp: print value of as[0] +PASS: gdb.cp/ref-types.exp: ptype as +PASS: gdb.cp/ref-types.exp: print value of as[1] +PASS: gdb.cp/ref-types.exp: print value of as[2] +PASS: gdb.cp/ref-types.exp: print value of as[3] +PASS: gdb.cp/ref-types.exp: print value of rs +PASS: gdb.cp/ref-types.exp: ptype rs +PASS: gdb.cp/ref-types.exp: print value of *rps +PASS: gdb.cp/ref-types.exp: examine value at rps +PASS: gdb.cp/ref-types.exp: ptype rps +PASS: gdb.cp/ref-types.exp: print value of ras[0] +PASS: gdb.cp/ref-types.exp: ptype ras +PASS: gdb.cp/ref-types.exp: print value of ras[1] +PASS: gdb.cp/ref-types.exp: print value of ras[2] +PASS: gdb.cp/ref-types.exp: print value of ras[3] +PASS: gdb.cp/ref-types.exp: up from f +PASS: gdb.cp/ref-types.exp: print value of C +PASS: gdb.cp/ref-types.exp: ptype C +PASS: gdb.cp/ref-types.exp: print value of UC +PASS: gdb.cp/ref-types.exp: ptype UC +PASS: gdb.cp/ref-types.exp: print value of S +PASS: gdb.cp/ref-types.exp: ptype S +PASS: gdb.cp/ref-types.exp: print value of US +PASS: gdb.cp/ref-types.exp: ptype US +PASS: gdb.cp/ref-types.exp: print value of I +PASS: gdb.cp/ref-types.exp: ptype I +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: ptype UI +PASS: gdb.cp/ref-types.exp: print value of L +PASS: gdb.cp/ref-types.exp: ptype L +PASS: gdb.cp/ref-types.exp: print value of UL +PASS: gdb.cp/ref-types.exp: ptype UL +PASS: gdb.cp/ref-types.exp: print value of F +PASS: gdb.cp/ref-types.exp: ptype F +PASS: gdb.cp/ref-types.exp: print value of D +PASS: gdb.cp/ref-types.exp: ptype D +PASS: gdb.cp/ref-types.exp: ptype rC +PASS: gdb.cp/ref-types.exp: ptype rUC +PASS: gdb.cp/ref-types.exp: ptype rS +PASS: gdb.cp/ref-types.exp: ptype rUS +PASS: gdb.cp/ref-types.exp: ptype rI +PASS: gdb.cp/ref-types.exp: ptype rUI +PASS: gdb.cp/ref-types.exp: ptype rL +PASS: gdb.cp/ref-types.exp: ptype rUL +PASS: gdb.cp/ref-types.exp: ptype rF +PASS: gdb.cp/ref-types.exp: ptype rD +PASS: gdb.cp/ref-types.exp: print value of rC +PASS: gdb.cp/ref-types.exp: print value of rUC +PASS: gdb.cp/ref-types.exp: print value of rS +PASS: gdb.cp/ref-types.exp: print value of rUS +PASS: gdb.cp/ref-types.exp: print value of rI +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: print value of rL +PASS: gdb.cp/ref-types.exp: print value of rUL +PASS: gdb.cp/ref-types.exp: print value of rF +PASS: gdb.cp/ref-types.exp: print value of rD +Running ./gdb.cp/re-set-overloaded.exp ... +PASS: gdb.cp/re-set-overloaded.exp: set breakpoint pending yes +PASS: gdb.cp/re-set-overloaded.exp: break C::C +PASS: gdb.cp/re-set-overloaded.exp: set variable $brk = $bpnum +PASS: gdb.cp/re-set-overloaded.exp: start +KFAIL: gdb.cp/re-set-overloaded.exp: breakpoint resolved (PRMS: breakpoints/11657) +Running ./gdb.cp/rtti.exp ... +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in main +PASS: gdb.cp/rtti.exp: print *e1 +PASS: gdb.cp/rtti.exp: print *e2 +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func +PASS: gdb.cp/rtti.exp: print *obj +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func3 +PASS: gdb.cp/rtti.exp: print *obj3 +Running ./gdb.cp/shadow.exp ... +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker1 +PASS: gdb.cp/shadow.exp: Print class x shadowing global x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker2 +PASS: gdb.cp/shadow.exp: Print local x shadowing class x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker3 +PASS: gdb.cp/shadow.exp: Print inner scope x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker4 +PASS: gdb.cp/shadow.exp: Print local x not namespace x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker5 +PASS: gdb.cp/shadow.exp: Print imported namespace x +Running ./gdb.cp/smartp.exp ... +PASS: gdb.cp/smartp.exp: continue to breakpoint: end of main +PASS: gdb.cp/smartp.exp: p mp->foo() +PASS: gdb.cp/smartp.exp: p mtp->foo() +PASS: gdb.cp/smartp.exp: p mt1.foo() +PASS: gdb.cp/smartp.exp: p mt4p.a +PASS: gdb.cp/smartp.exp: p mt4->a +PASS: gdb.cp/smartp.exp: p sp1->foo() +PASS: gdb.cp/smartp.exp: p sp2->foo() +PASS: gdb.cp/smartp.exp: p sp3->foo(1) +PASS: gdb.cp/smartp.exp: p sp3->foo('a') +PASS: gdb.cp/smartp.exp: p sp4->a +PASS: gdb.cp/smartp.exp: p sp4->b +PASS: gdb.cp/smartp.exp: p mt4p->a +PASS: gdb.cp/smartp.exp: p mt4p->b +PASS: gdb.cp/smartp.exp: p mt4->fake +PASS: gdb.cp/smartp.exp: p mt4->fake() +PASS: gdb.cp/smartp.exp: p b->foo() +PASS: gdb.cp/smartp.exp: p c->foo() +PASS: gdb.cp/smartp.exp: p c->inta +KFAIL: gdb.cp/smartp.exp: p c2->inta (PRMS: gdb/11606) +Running ./gdb.cp/static-method.exp ... +PASS: gdb.cp/static-method.exp: info addr A::func() +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::A::func' +Running ./gdb.cp/static-print-quit.exp ... +PASS: gdb.cp/static-print-quit.exp: set width 80 +PASS: gdb.cp/static-print-quit.exp: set height 2 +PASS: gdb.cp/static-print-quit.exp: print c - <return> +PASS: gdb.cp/static-print-quit.exp: print c - q <return> +PASS: gdb.cp/static-print-quit.exp: print c - to quit +PASS: gdb.cp/static-print-quit.exp: q +PASS: gdb.cp/static-print-quit.exp: set pagination off +PASS: gdb.cp/static-print-quit.exp: first print +PASS: gdb.cp/static-print-quit.exp: second print +Running ./gdb.cp/temargs.exp ... +PASS: gdb.cp/temargs.exp: set first breakpoint for temargs +PASS: gdb.cp/temargs.exp: set second breakpoint for temargs +PASS: gdb.cp/temargs.exp: set third breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set sixth breakpoint for temargs +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to first breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in base_m +PASS: gdb.cp/temargs.exp: test value of I in base_m +PASS: gdb.cp/temargs.exp: test value of P in base_m +PASS: gdb.cp/temargs.exp: test value of MP in base_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to second breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in inner_m +PASS: gdb.cp/temargs.exp: test value of I in inner_m +PASS: gdb.cp/temargs.exp: test value of P in inner_m +PASS: gdb.cp/temargs.exp: test value of MP in inner_m +PASS: gdb.cp/temargs.exp: test type of Z in inner_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to third breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in func +PASS: gdb.cp/temargs.exp: test value of I in func +PASS: gdb.cp/temargs.exp: test value of P in func +PASS: gdb.cp/temargs.exp: test value of MP in func +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in templ_m +PASS: gdb.cp/temargs.exp: test value of I in templ_m +PASS: gdb.cp/temargs.exp: test value of P in templ_m +PASS: gdb.cp/temargs.exp: test value of MP in templ_m +PASS: gdb.cp/temargs.exp: test type of Q in templ_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of F in k2_m +XFAIL: gdb.cp/temargs.exp: test value of F in k2_m (PRMS gcc/49366) +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to sixth breakpoint for temargs +XFAIL: gdb.cp/temargs.exp: test type of F in k3_m (PRMS gcc/49546) +XFAIL: gdb.cp/temargs.exp: test value of F in k3_m (PRMS gcc/49546) +Running ./gdb.cp/templates.exp ... +PASS: gdb.cp/templates.exp: set multiple-symbols ask +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +PASS: gdb.cp/templates.exp: constructor breakpoint +PASS: gdb.cp/templates.exp: destructor breakpoint +PASS: gdb.cp/templates.exp: value method breakpoint +PASS: gdb.cp/templates.exp: breakpoint on a line with no real code +PASS: gdb.cp/templates.exp: print method of template typedef +XFAIL: gdb.cp/templates.exp: print destructor of template typedef (PRMS gcc/51668) +PASS: gdb.cp/templates.exp: verify GCC PR debug/51668 +PASS: gdb.cp/templates.exp: ptype empty +PASS: gdb.cp/templates.exp: ptype arg +PASS: gdb.cp/templates.exp: print t5i.value() +PASS: gdb.cp/templates.exp: b 770 +PASS: gdb.cp/templates.exp: continue to line 770 +PASS: gdb.cp/templates.exp: print fint +PASS: gdb.cp/templates.exp: print fvpchar +PASS: gdb.cp/templates.exp: ptype Foo +PASS: gdb.cp/templates.exp: ptype fint +PASS: gdb.cp/templates.exp: ptype fchar +KFAIL: gdb.cp/templates.exp: ptype fvpchar (PRMS: gdb/1512) +PASS: gdb.cp/templates.exp: print Foo<volatile char *>::foo +PASS: gdb.cp/templates.exp: print Foo<volatile char*>::foo +PASS: gdb.cp/templates.exp: ptype Bar +PASS: gdb.cp/templates.exp: ptype bint +PASS: gdb.cp/templates.exp: ptype bint2 +PASS: gdb.cp/templates.exp: ptype Baz +PASS: gdb.cp/templates.exp: ptype bazint +PASS: gdb.cp/templates.exp: ptype bazint2 +PASS: gdb.cp/templates.exp: ptype Qux +PASS: gdb.cp/templates.exp: ptype quxint +PASS: gdb.cp/templates.exp: ptype Spec +PASS: gdb.cp/templates.exp: ptype siip +PASS: gdb.cp/templates.exp: ptype Garply<int> +PASS: gdb.cp/templates.exp: ptype Garply<Garply<char> > +PASS: gdb.cp/templates.exp: print Garply<Garply<char> >::garply +PASS: gdb.cp/templates.exp: break Garply<Garply<char> >::garply +Running ./gdb.cp/try_catch.exp ... +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-start +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-next +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-catch +Running ./gdb.cp/typedef-operator.exp ... +PASS: gdb.cp/typedef-operator.exp: set language c++ +PASS: gdb.cp/typedef-operator.exp: test crash +PASS: gdb.cp/typedef-operator.exp: test typedef +Running ./gdb.cp/userdef.exp ... +PASS: gdb.cp/userdef.exp: break marker1 +PASS: gdb.cp/userdef.exp: continue to marker1 +PASS: gdb.cp/userdef.exp: up from marker1 +PASS: gdb.cp/userdef.exp: print one + two +PASS: gdb.cp/userdef.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/userdef.exp: print one - two +PASS: gdb.cp/userdef.exp: print one * two +PASS: gdb.cp/userdef.exp: print one / two +PASS: gdb.cp/userdef.exp: print one % two +PASS: gdb.cp/userdef.exp: print one && two +PASS: gdb.cp/userdef.exp: print one || two +PASS: gdb.cp/userdef.exp: print one & two +PASS: gdb.cp/userdef.exp: print one | two +PASS: gdb.cp/userdef.exp: print one ^ two +PASS: gdb.cp/userdef.exp: print one < two +PASS: gdb.cp/userdef.exp: print one <= two +PASS: gdb.cp/userdef.exp: print one > two +PASS: gdb.cp/userdef.exp: print one >= two +PASS: gdb.cp/userdef.exp: print one == two +PASS: gdb.cp/userdef.exp: print one.operator== (two) +PASS: gdb.cp/userdef.exp: print one != two +PASS: gdb.cp/userdef.exp: print one << 31 +PASS: gdb.cp/userdef.exp: print one >> 31 +PASS: gdb.cp/userdef.exp: print !one +PASS: gdb.cp/userdef.exp: print +one +PASS: gdb.cp/userdef.exp: print ~one +PASS: gdb.cp/userdef.exp: print -one +PASS: gdb.cp/userdef.exp: print one++ +PASS: gdb.cp/userdef.exp: print ++one +PASS: gdb.cp/userdef.exp: print one-- +PASS: gdb.cp/userdef.exp: print --one +PASS: gdb.cp/userdef.exp: print one += 7 +PASS: gdb.cp/userdef.exp: print two = one +PASS: gdb.cp/userdef.exp: break A2::operator+ +PASS: gdb.cp/userdef.exp: break A2::operator + +PASS: gdb.cp/userdef.exp: print c +PASS: gdb.cp/userdef.exp: print *c +PASS: gdb.cp/userdef.exp: print &*c +PASS: gdb.cp/userdef.exp: ptype &*c +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem2) +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem1) +Running ./gdb.cp/using-crash.exp ... +PASS: gdb.cp/using-crash.exp: reload file +Running ./gdb.cp/virtbase.exp ... +PASS: gdb.cp/virtbase.exp: continue to breakpoint: first breakpoint +PASS: gdb.cp/virtbase.exp: print *this +PASS: gdb.cp/virtbase.exp: print x in get_y +PASS: gdb.cp/virtbase.exp: continue to breakpoint: second breakpoint +PASS: gdb.cp/virtbase.exp: print x in get_z +PASS: gdb.cp/virtbase.exp: continue to breakpoint: third breakpoint +PASS: gdb.cp/virtbase.exp: print *(D *) e +PASS: gdb.cp/virtbase.exp: set print object on +PASS: gdb.cp/virtbase.exp: print/x b->mA +PASS: gdb.cp/virtbase.exp: print rtti_data +PASS: gdb.cp/virtbase.exp: print pointer to virtual base at non-zero offset of larger object +PASS: gdb.cp/virtbase.exp: print same pointer from history value +PASS: gdb.cp/virtbase.exp: print whole pointed-to object, starting from the virtual base pointer +Running ./gdb.cp/virtfunc2.exp ... +PASS: gdb.cp/virtfunc2.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/virtfunc2.exp: print o.do_print() +PASS: gdb.cp/virtfunc2.exp: print o.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print2() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o +Running ./gdb.cp/virtfunc.exp ... +PASS: gdb.cp/virtfunc.exp: ptype VA +PASS: gdb.cp/virtfunc.exp: ptype VB +PASS: gdb.cp/virtfunc.exp: ptype V +PASS: gdb.cp/virtfunc.exp: ptype A +PASS: gdb.cp/virtfunc.exp: ptype B +PASS: gdb.cp/virtfunc.exp: ptype C +PASS: gdb.cp/virtfunc.exp: ptype AD +PASS: gdb.cp/virtfunc.exp: ptype D +PASS: gdb.cp/virtfunc.exp: ptype E +PASS: gdb.cp/virtfunc.exp: ptype dd +PASS: gdb.cp/virtfunc.exp: ptype ppd +PASS: gdb.cp/virtfunc.exp: ptype pAd +PASS: gdb.cp/virtfunc.exp: ptype a +PASS: gdb.cp/virtfunc.exp: ptype b +PASS: gdb.cp/virtfunc.exp: ptype c +PASS: gdb.cp/virtfunc.exp: ptype d +PASS: gdb.cp/virtfunc.exp: ptype e +PASS: gdb.cp/virtfunc.exp: ptype v +PASS: gdb.cp/virtfunc.exp: ptype vb +PASS: gdb.cp/virtfunc.exp: ptype pAa +PASS: gdb.cp/virtfunc.exp: ptype pAe +PASS: gdb.cp/virtfunc.exp: ptype pBe +PASS: gdb.cp/virtfunc.exp: ptype pDd +PASS: gdb.cp/virtfunc.exp: ptype pDe +PASS: gdb.cp/virtfunc.exp: ptype pVa +PASS: gdb.cp/virtfunc.exp: ptype pVv +PASS: gdb.cp/virtfunc.exp: ptype pVe +PASS: gdb.cp/virtfunc.exp: ptype pVd +PASS: gdb.cp/virtfunc.exp: ptype pADe +PASS: gdb.cp/virtfunc.exp: ptype pEe +PASS: gdb.cp/virtfunc.exp: ptype pVB +PASS: gdb.cp/virtfunc.exp: info vtbl a +PASS: gdb.cp/virtfunc.exp: info vtbl b +PASS: gdb.cp/virtfunc.exp: info vtbl c +PASS: gdb.cp/virtfunc.exp: info vtbl d +FAIL: gdb.cp/virtfunc.exp: info vtbl e +FAIL: gdb.cp/virtfunc.exp: info vtbl pEe +PASS: gdb.cp/virtfunc.exp: info vtbl +PASS: gdb.cp/virtfunc.exp: info vtbl va +PASS: gdb.cp/virtfunc.exp: info vtbl all_count +PASS: gdb.cp/virtfunc.exp: print pAe->f() +PASS: gdb.cp/virtfunc.exp: print pAa->f() +PASS: gdb.cp/virtfunc.exp: print pDe->vg() +PASS: gdb.cp/virtfunc.exp: print pADe->vg() +PASS: gdb.cp/virtfunc.exp: print pDd->vg() +PASS: gdb.cp/virtfunc.exp: print pEe->vvb() +PASS: gdb.cp/virtfunc.exp: print pVB->vvb() +PASS: gdb.cp/virtfunc.exp: print pBe->vvb() +PASS: gdb.cp/virtfunc.exp: print pDe->vvb() +PASS: gdb.cp/virtfunc.exp: print pEe->vd() +PASS: gdb.cp/virtfunc.exp: print pEe->fvb() +KFAIL: gdb.cp/virtfunc.exp: print pEe->D::vg() (PRMS: gdb/1064) +PASS: gdb.cp/virtfunc.exp: next to pAa->f call +PASS: gdb.cp/virtfunc.exp: next to pDe->vg call +PASS: gdb.cp/virtfunc.exp: step through thunk into E::vg +Running ./gdb.disasm/am33.exp ... +Running ./gdb.disasm/h8300s.exp ... +Running ./gdb.disasm/hppa.exp ... +Running ./gdb.disasm/mn10300.exp ... +Running ./gdb.disasm/sh3.exp ... +Running ./gdb.disasm/t01_mov.exp ... +Running ./gdb.disasm/t02_mova.exp ... +Running ./gdb.disasm/t03_add.exp ... +Running ./gdb.disasm/t04_sub.exp ... +Running ./gdb.disasm/t05_cmp.exp ... +Running ./gdb.disasm/t06_ari2.exp ... +Running ./gdb.disasm/t07_ari3.exp ... +Running ./gdb.disasm/t08_or.exp ... +Running ./gdb.disasm/t09_xor.exp ... +Running ./gdb.disasm/t10_and.exp ... +Running ./gdb.disasm/t11_logs.exp ... +Running ./gdb.disasm/t12_bit.exp ... +Running ./gdb.disasm/t13_otr.exp ... +Running ./gdb.dwarf2/callframecfa.exp ... +Running ./gdb.dwarf2/clztest.exp ... +Running ./gdb.dwarf2/dup-psym.exp ... +PASS: gdb.dwarf2/dup-psym.exp: info sources should contain only one reference to file1.txt +Running ./gdb.dwarf2/dw2-ada-ffffffff.exp ... +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: p sizeof (t) +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: ptype t +Running ./gdb.dwarf2/dw2-anon-mptr.exp ... +PASS: gdb.dwarf2/dw2-anon-mptr.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-anon-mptr.exp: show cp-abi +PASS: gdb.dwarf2/dw2-anon-mptr.exp: ptype crash +Running ./gdb.dwarf2/dw2-anonymous-func.exp ... +PASS: gdb.dwarf2/dw2-anonymous-func.exp: list file1.txt +Running ./gdb.dwarf2/dw2-bad-parameter-type.exp ... +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: is alive +Running ./gdb.dwarf2/dw2-basic.exp ... +PASS: gdb.dwarf2/dw2-basic.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-basic.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-basic.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-canonicalize-type.exp ... +PASS: gdb.dwarf2/dw2-canonicalize-type.exp: ptype f +Running ./gdb.dwarf2/dw2-case-insensitive.exp ... +PASS: gdb.dwarf2/dw2-case-insensitive.exp: show case-sensitive +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive on +PASS: gdb.dwarf2/dw2-case-insensitive.exp: set case-sensitive off +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive off +FAIL: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_symtab +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_symtab +Running ./gdb.dwarf2/dw2-common-block.exp ... +Running ./gdb.dwarf2/dw2-compdir-oldgcc.exp ... +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc43 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc43 +Running ./gdb.dwarf2/dw2-compressed.exp ... +PASS: gdb.dwarf2/dw2-compressed.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-compressed.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-compressed.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-const.exp ... +PASS: gdb.dwarf2/dw2-const.exp: print twelve +PASS: gdb.dwarf2/dw2-const.exp: print/x val8 +Running ./gdb.dwarf2/dw2-cp-infcall-ref-static.exp ... +PASS: gdb.dwarf2/dw2-cp-infcall-ref-static.exp: set language c++ +PASS: gdb.dwarf2/dw2-cp-infcall-ref-static.exp: set cp-abi gnu-v3 +ERROR: Process no longer exists +UNRESOLVED: gdb.dwarf2/dw2-cp-infcall-ref-static.exp: p f() +Running ./gdb.dwarf2/dw2-cu-size.exp ... +PASS: gdb.dwarf2/dw2-cu-size.exp: ptype noloc +Running ./gdb.dwarf2/dw2-dir-file-name.exp ... +PASS: gdb.dwarf2/dw2-dir-file-name.exp: cd .../rdir +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: continue to breakpoint: compdir_missing__ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: continue to breakpoint: compdir_missing__ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: continue to breakpoint: compdir_missing__ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: continue to breakpoint: compdir_missing__ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: continue to breakpoint: compdir_missing__ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: continue to breakpoint: compdir_missing__ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: continue to breakpoint: compdir_missing__ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: continue to breakpoint: compdir_missing__ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: continue to breakpoint: compdir_relative_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: continue to breakpoint: compdir_relative_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: continue to breakpoint: compdir_relative_ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: continue to breakpoint: compdir_relative_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: continue to breakpoint: compdir_relative_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: continue to breakpoint: compdir_relative_ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: continue to breakpoint: compdir_relative_ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: continue to breakpoint: compdir_relative_ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: continue to breakpoint: compdir_absolute_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: continue to breakpoint: compdir_absolute_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: continue to breakpoint: compdir_absolute_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: continue to breakpoint: compdir_absolute_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_basename_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_relative_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: relative +Running ./gdb.dwarf2/dw2-dos-drive.exp ... +PASS: gdb.dwarf2/dw2-dos-drive.exp: set breakpoint pending off +FAIL: gdb.dwarf2/dw2-dos-drive.exp: break 'z:file.c':func +UNSUPPORTED: gdb.dwarf2/dw2-dos-drive.exp: break file.c:func +Running ./gdb.dwarf2/dw2-double-set-die-type.exp ... +PASS: gdb.dwarf2/dw2-double-set-die-type.exp: ptype a +Running ./gdb.dwarf2/dw2-empty-namespace.exp ... +PASS: gdb.dwarf2/dw2-empty-namespace.exp: ptype var +PASS: gdb.dwarf2/dw2-empty-namespace.exp: p var +Running ./gdb.dwarf2/dw2-empty-pc-range.exp ... +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range before CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: valid range after CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range after CU load +Running ./gdb.dwarf2/dw2-entry-value.exp ... +FAIL: gdb.dwarf2/dw2-entry-value.exp: <optimized out> is printed +Running ./gdb.dwarf2/dw2-error.exp ... +gdb compile failed, dw2-error.c: Assembler messages: +dw2-error.c:25: Error: unrecognized symbol type "" +dw2-error.c:33: Error: bad instruction `pushq %rbp' +dw2-error.c:36: Error: bad instruction `movq %rsp,%rbp' +dw2-error.c:40: Error: bad instruction `movl $23,%eax' +dw2-error.c:43: Error: bad instruction `popq %rbp' +dw2-error.c:45: Error: bad instruction `ret' +dw2-error.c:50: Error: junk at end of line, first unrecognized character is `,' +dw2-error.c:52: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:53: Error: unknown pseudo-op: `.value' +dw2-error.c:54: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:55: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:56: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:57: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:58: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:59: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:60: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:61: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:62: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:63: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:64: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:66: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:67: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:68: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:69: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:70: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:71: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:72: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:73: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:75: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:76: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:77: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:78: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:79: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:80: Error: junk at end of line, first unrecognized character is `,' +dw2-error.c:82: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:83: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:84: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:85: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:86: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:87: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:88: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:89: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:90: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:91: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:92: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:93: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:94: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:95: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:96: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:97: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:98: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:101: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:102: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:103: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:104: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:105: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:106: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:107: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:108: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:109: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:110: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:111: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:112: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:113: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:114: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:115: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:116: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:117: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:118: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:119: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:120: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:121: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:124: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:125: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:126: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:127: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:128: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:129: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:130: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:131: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:132: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:136: Error: junk at end of line, first unrecognized character is `,' +dw2-error.c:137: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:138: Error: unknown pseudo-op: `.value' +dw2-error.c:139: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:140: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:141: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:142: Error: unknown pseudo-op: `.value' +dw2-error.c:143: Error: unknown pseudo-op: `.value' +dw2-error.c:144: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:145: Error: junk at end of line, first unrecognized character is `#' +dw2-error.c:148: Error: junk at end of line, first unrecognized character is `,' +dw2-error.c:160: Error: junk at end of line, first unrecognized character is `,' +UNTESTED: gdb.dwarf2/dw2-error.exp: dw2-error.exp +Running ./gdb.dwarf2/dw2-filename.exp ... +PASS: gdb.dwarf2/dw2-filename.exp: interpreter-exec mi -file-list-exec-source-files +PASS: gdb.dwarf2/dw2-filename.exp: info sources +Running ./gdb.dwarf2/dw2-icc-opaque.exp ... +PASS: gdb.dwarf2/dw2-icc-opaque.exp: ptype p_struct +Running ./gdb.dwarf2/dw2-ifort-parameter.exp ... +FAIL: gdb.dwarf2/dw2-ifort-parameter.exp: p/x param +Running ./gdb.dwarf2/dw2-inheritance.exp ... +PASS: gdb.dwarf2/dw2-inheritance.exp: ptype inherited +Running ./gdb.dwarf2/dw2-inline-break.exp ... +Running ./gdb.dwarf2/dw2-inline-param.exp ... +PASS: gdb.dwarf2/dw2-inline-param.exp: info addr break_at +Running ./gdb.dwarf2/dw2-intercu.exp ... +PASS: gdb.dwarf2/dw2-intercu.exp: ptype int2 +PASS: gdb.dwarf2/dw2-intercu.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-intercu.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-intercu.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-intermix.exp ... +gdb compile failed, ./gdb.dwarf2/dw2-intermix.S: Assembler messages: +./gdb.dwarf2/dw2-intermix.S:139: Error: bad relocation fixup type (1) +./gdb.dwarf2/dw2-intermix.S:142: Error: bad relocation fixup type (1) +UNTESTED: gdb.dwarf2/dw2-intermix.exp: dw2-intermix.exp +Running ./gdb.dwarf2/dw2-linkage-name-trust.exp ... +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set language c++ +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername () +Running ./gdb.dwarf2/dw2-minsym-in-cu.exp ... +PASS: gdb.dwarf2/dw2-minsym-in-cu.exp: info fun func2 +Running ./gdb.dwarf2/dw2-modula2-self-type.exp ... +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: set language modula-2 +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: ptype v +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: alive +Running ./gdb.dwarf2/dw2-namespaceless-anonymous.exp ... +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: ptype '(anonymous namespace)::v' +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: p '(anonymous namespace)::v' +Running ./gdb.dwarf2/dw2-noloc.exp ... +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: print file_extern_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: no-run: ptype file_extern_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: print file_extern_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: in-main: ptype file_extern_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_local_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_local_locno_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_extern_locaddr_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_extern_locaddr_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_extern_locempty_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_extern_locempty_unresolvable +PASS: gdb.dwarf2/dw2-noloc.exp: print main_extern_locno_resolvable +PASS: gdb.dwarf2/dw2-noloc.exp: ptype main_extern_locno_resolvable +Running ./gdb.dwarf2/dw2-objfile-overlap.exp ... +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: add-symbol-file +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: info line inner +Running ./gdb.dwarf2/dw2-op-call.exp ... +PASS: gdb.dwarf2/dw2-op-call.exp: maintenance set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw2-op-call.exp: p array1 +PASS: gdb.dwarf2/dw2-op-call.exp: array2 using DW_OP_call2 +PASS: gdb.dwarf2/dw2-op-call.exp: array3 using DW_OP_call4 +PASS: gdb.dwarf2/dw2-op-call.exp: p arraynoloc +PASS: gdb.dwarf2/dw2-op-call.exp: p arraycallnoloc +Running ./gdb.dwarf2/dw2-op-out-param.exp ... +Running ./gdb.dwarf2/dw2-op-stack-value.exp ... +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack8 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: x/wx &aa551234 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to4 +Running ./gdb.dwarf2/dw2-param-error.exp ... +FAIL: gdb.dwarf2/dw2-param-error.exp: frame +Running ./gdb.dwarf2/dw2-producer.exp ... +PASS: gdb.dwarf2/dw2-producer.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-producer.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-producer.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-ranges.exp ... +PASS: gdb.dwarf2/dw2-ranges.exp: info line main +PASS: gdb.dwarf2/dw2-ranges.exp: info line func +PASS: gdb.dwarf2/dw2-ranges.exp: info line main2 +PASS: gdb.dwarf2/dw2-ranges.exp: info line func2 +KFAIL: gdb.dwarf2/dw2-ranges.exp: info line main3 (PRMS: symtab/12497) +Running ./gdb.dwarf2/dw2-ref-missing-frame.exp ... +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_nofb print +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_nofb backtrace +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb print +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb backtrace +Running ./gdb.dwarf2/dw2-restore.exp ... +Running ./gdb.dwarf2/dw2-restrict.exp ... +Running ./gdb.dwarf2/dw2-simple-locdesc.exp ... +KFAIL: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.shl (PRMS: symtab/13307) +PASS: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.data4 +Running ./gdb.dwarf2/dw2-skip-prologue.exp ... +PASS: gdb.dwarf2/dw2-skip-prologue.exp: strip stub symbols +PASS: gdb.dwarf2/dw2-skip-prologue.exp: continue to breakpoint: func +FAIL: gdb.dwarf2/dw2-skip-prologue.exp: 2 locations found +FAIL: gdb.dwarf2/dw2-skip-prologue.exp: no statement got executed +Running ./gdb.dwarf2/dw2-stack-boundary.exp ... +PASS: gdb.dwarf2/dw2-stack-boundary.exp: set complaints 100 +PASS: gdb.dwarf2/dw2-stack-boundary.exp: check partial symtab errors +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p underflow +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p overflow +Running ./gdb.dwarf2/dw2-strp.exp ... +PASS: gdb.dwarf2/dw2-strp.exp: p a_string +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string +PASS: gdb.dwarf2/dw2-strp.exp: p a_string2 +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string2 +Running ./gdb.dwarf2/dw2-unresolved.exp ... +PASS: gdb.dwarf2/dw2-unresolved.exp: continue to breakpoint: *extern_block_start +PASS: gdb.dwarf2/dw2-unresolved.exp: print/d var +Running ./gdb.dwarf2/dw2-var-zero-addr.exp ... +PASS: gdb.dwarf2/dw2-var-zero-addr.exp: print &var +Running ./gdb.dwarf2/dw4-sig-types.exp ... +PASS: gdb.dwarf2/dw4-sig-types.exp: maint set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw4-sig-types.exp: p myset +PASS: gdb.dwarf2/dw4-sig-types.exp: continue to foo +Running ./gdb.dwarf2/dw4-sig-type-unused.exp ... +PASS: gdb.dwarf2/dw4-sig-type-unused.exp: alive +Running ./gdb.dwarf2/fission-base.exp ... +Running ./gdb.dwarf2/fission-loclists.exp ... +Running ./gdb.dwarf2/fission-reread.exp ... +gdb compile failed, fission-reread.cc: Assembler messages: +fission-reread.cc:46: Error: unrecognized symbol type "" +fission-reread.cc:54: Error: unrecognized symbol type "" +UNTESTED: gdb.dwarf2/fission-reread.exp: fission-reread.exp +Running ./gdb.dwarf2/implptr-64bit.exp ... +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +Running ./gdb.dwarf2/implptr.exp ... +Running ./gdb.dwarf2/implptr-optimized-out.exp ... +PASS: gdb.dwarf2/implptr-optimized-out.exp: p p->f +Running ./gdb.dwarf2/mac-fileno.exp ... +gdb compile failed, ./gdb.dwarf2/mac-fileno.S: Assembler messages: +./gdb.dwarf2/mac-fileno.S:203: Error: junk at end of line, first unrecognized character is `,' +UNTESTED: gdb.dwarf2/mac-fileno.exp: mac-fileno.exp +Running ./gdb.dwarf2/member-ptr-forwardref.exp ... +gdb compile failed, member-ptr-forwardref.cc: Assembler messages: +member-ptr-forwardref.cc:34: Error: junk at end of line, first unrecognized character is `,' +member-ptr-forwardref.cc:36: Error: junk at end of line, first unrecognized character is `,' +member-ptr-forwardref.cc:38: Error: junk at end of line, first unrecognized character is `,' +member-ptr-forwardref.cc:45: Error: unrecognized symbol type "" +member-ptr-forwardref.cc:51: Error: unrecognized symbol type "" +member-ptr-forwardref.cc:293: Error: junk at end of line, first unrecognized character is `,' +member-ptr-forwardref.cc:303: Error: junk at end of line, first unrecognized character is `,' +member-ptr-forwardref.cc:327: Error: junk at end of line, first unrecognized character is `,' +UNTESTED: gdb.dwarf2/member-ptr-forwardref.exp: member-ptr-forwardref.exp +Running ./gdb.dwarf2/method-ptr.exp ... +PASS: gdb.dwarf2/method-ptr.exp: ptype the_typedef +Running ./gdb.dwarf2/pieces.exp ... +Running ./gdb.dwarf2/pr10770.exp ... +PASS: gdb.dwarf2/pr10770.exp: set breakpoint for pr10770 +PASS: gdb.dwarf2/pr10770.exp: cont +PASS: gdb.dwarf2/pr10770.exp: frame 2 +Running ./gdb.dwarf2/pr11465.exp ... +PASS: gdb.dwarf2/pr11465.exp: p N::c.C +Running ./gdb.dwarf2/pr13961.exp ... +gdb compile failed, pr13961.cc: Assembler messages: +pr13961.cc:45: Error: unrecognized symbol type "" +pr13961.cc:59: Error: unrecognized symbol type "" +pr13961.cc:67: Error: junk at end of line, first unrecognized character is `,' +pr13961.cc:124: Error: junk at end of line, first unrecognized character is `,' +pr13961.cc:208: Error: junk at end of line, first unrecognized character is `,' +pr13961.cc:336: Error: junk at end of line, first unrecognized character is `,' +pr13961.cc:349: Error: junk at end of line, first unrecognized character is `,' +UNTESTED: gdb.dwarf2/pr13961.exp: pr13961.exp +Running ./gdb.dwarf2/subrange.exp ... +PASS: gdb.dwarf2/subrange.exp: set language pascal +PASS: gdb.dwarf2/subrange.exp: ptype TByteArray +Running ./gdb.dwarf2/trace-crash.exp ... +Running ./gdb.dwarf2/typeddwarf.exp ... +Running ./gdb.dwarf2/valop.exp ... +Running ./gdb.dwarf2/watch-notconst.exp ... +Running ./gdb.fortran/array-element.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/array-element.exp: array-element.exp +Running ./gdb.fortran/charset.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/charset.exp: charset.exp +Running ./gdb.fortran/common-block.exp ... +UNTESTED: gdb.fortran/common-block.exp: common-block.exp +Running ./gdb.fortran/complex.exp ... +UNTESTED: gdb.fortran/complex.exp: complex.exp +UNTESTED: gdb.fortran/complex.exp: Couldn't compile complex.f +Running ./gdb.fortran/derived-type.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/derived-type.exp: derived-type.exp +Running ./gdb.fortran/exprs.exp ... +PASS: gdb.fortran/exprs.exp: set print sevenbit-strings +PASS: gdb.fortran/exprs.exp: set language fortran +PASS: gdb.fortran/exprs.exp: set language to "fortran" +PASS: gdb.fortran/exprs.exp: Set value-history[1] using $1 +PASS: gdb.fortran/exprs.exp: Set value-history[2] using $2 +PASS: gdb.fortran/exprs.exp: Set value-history[3] using $3 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.fortran/exprs.exp: Print value-history[1] using explicit index $1 +PASS: gdb.fortran/exprs.exp: Print value-history[2] using explicit index $2 +PASS: gdb.fortran/exprs.exp: Print value-history[3] using explicit index $3 +PASS: gdb.fortran/exprs.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.fortran/exprs.exp: Use value-history element in arithmetic expression +PASS: gdb.fortran/exprs.exp: Set a new convenience variable +PASS: gdb.fortran/exprs.exp: Print contents of new convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable to a new value +PASS: gdb.fortran/exprs.exp: Print new contents of convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable $_ +PASS: gdb.fortran/exprs.exp: Print contents of convenience variable $_ +PASS: gdb.fortran/exprs.exp: Use convenience variable in arithmetic expression +PASS: gdb.fortran/exprs.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.fortran/exprs.exp: Print contents of uninitialized convenience variable +PASS: gdb.fortran/exprs.exp: p 123 +PASS: gdb.fortran/exprs.exp: p -123 +PASS: gdb.fortran/exprs.exp: reject p _ +PASS: gdb.fortran/exprs.exp: p .TRUE. +PASS: gdb.fortran/exprs.exp: p .FALSE. +PASS: gdb.fortran/exprs.exp: p 'a' +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(2:4) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:3) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(5:) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:) +PASS: gdb.fortran/exprs.exp: p .44 .LT. .45 +PASS: gdb.fortran/exprs.exp: p .44 .GT. .45 +PASS: gdb.fortran/exprs.exp: p 0.44 .LT. 0.45 +PASS: gdb.fortran/exprs.exp: p 0.44 .GT. 0.45 +PASS: gdb.fortran/exprs.exp: p 44. .LT. 45. +PASS: gdb.fortran/exprs.exp: p 44. .GT. 45. +PASS: gdb.fortran/exprs.exp: p 44.0 .LT. 45.0 +PASS: gdb.fortran/exprs.exp: p 44.0 .GT. 45.0 +PASS: gdb.fortran/exprs.exp: p 10D20 .LT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10D20 .GT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10d20 .LT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10d20 .GT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10E20 .LT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10E20 .GT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10e20 .LT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10e20 .GT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .LT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .GT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .LT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .GT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .LT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .GT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .LT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .GT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .LT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .GT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .LT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .GT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .LT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .GT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .LT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .GT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .LT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .GT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .LT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .GT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .LT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .GT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .LT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .GT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .LT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .GT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .LT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .GT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .LT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .GT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .LT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .GT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: unary minus applied to int +PASS: gdb.fortran/exprs.exp: unary minus applied to real +PASS: gdb.fortran/exprs.exp: bool plus int +PASS: gdb.fortran/exprs.exp: int plus int +PASS: gdb.fortran/exprs.exp: real plus int +PASS: gdb.fortran/exprs.exp: real plus real +PASS: gdb.fortran/exprs.exp: bool minus int +PASS: gdb.fortran/exprs.exp: int minus int +PASS: gdb.fortran/exprs.exp: real minus int +PASS: gdb.fortran/exprs.exp: real minus real +PASS: gdb.fortran/exprs.exp: bool times int +PASS: gdb.fortran/exprs.exp: int times int +PASS: gdb.fortran/exprs.exp: real times int +PASS: gdb.fortran/exprs.exp: real times real +PASS: gdb.fortran/exprs.exp: bool divided by int +PASS: gdb.fortran/exprs.exp: int divided by int +PASS: gdb.fortran/exprs.exp: real divided by int +PASS: gdb.fortran/exprs.exp: real divided by real +PASS: gdb.fortran/exprs.exp: int powered by int +PASS: gdb.fortran/exprs.exp: combined exponentiation expression +PASS: gdb.fortran/exprs.exp: combined exponentiation expression in specified order +PASS: gdb.fortran/exprs.exp: int powered by real +PASS: gdb.fortran/exprs.exp: real powered by real +Running ./gdb.fortran/library-module.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/library-module.exp: Couldn't compile library-module-lib.f90 +Running ./gdb.fortran/logical.exp ... +UNTESTED: gdb.fortran/logical.exp: logical.exp +Running ./gdb.fortran/module.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/module.exp: module.exp +Running ./gdb.fortran/multi-dim.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/multi-dim.exp: multi-dim.exp +Running ./gdb.fortran/subarray.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gfortran. +UNTESTED: gdb.fortran/subarray.exp: subarray.exp +Running ./gdb.fortran/types.exp ... +PASS: gdb.fortran/types.exp: set print sevenbit-strings +PASS: gdb.fortran/types.exp: set language fortran +PASS: gdb.fortran/types.exp: set language to "fortran" +PASS: gdb.fortran/types.exp: pt 123 +PASS: gdb.fortran/types.exp: reject pt _ +PASS: gdb.fortran/types.exp: pt .TRUE. +PASS: gdb.fortran/types.exp: pt .FALSE. +PASS: gdb.fortran/types.exp: pt 'a' +PASS: gdb.fortran/types.exp: pt .44 +PASS: gdb.fortran/types.exp: pt 44.0 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10e20 +PASS: gdb.fortran/types.exp: pt 10e20 +Running ./gdb.gdb/complaints.exp ... +Running ./gdb.gdb/observer.exp ... +Running ./gdb.gdb/selftest.exp ... +Running ./gdb.gdb/xfullpath.exp ... +Running ./gdb.go/basic-types.exp ... +PASS: gdb.go/basic-types.exp: set language go +PASS: gdb.go/basic-types.exp: set language to "go" +PASS: gdb.go/basic-types.exp: pt 123 +PASS: gdb.go/basic-types.exp: pt void(42) +PASS: gdb.go/basic-types.exp: pt byte(42) +PASS: gdb.go/basic-types.exp: pt int(42) +PASS: gdb.go/basic-types.exp: pt uint(42) +PASS: gdb.go/basic-types.exp: pt uintptr(42) +PASS: gdb.go/basic-types.exp: pt int8(42) +PASS: gdb.go/basic-types.exp: pt int16(42) +PASS: gdb.go/basic-types.exp: pt int32(42) +PASS: gdb.go/basic-types.exp: pt int64(42) +PASS: gdb.go/basic-types.exp: pt uint8(42) +PASS: gdb.go/basic-types.exp: pt uint16(42) +PASS: gdb.go/basic-types.exp: pt uint32(42) +PASS: gdb.go/basic-types.exp: pt uint64(42) +PASS: gdb.go/basic-types.exp: pt true +PASS: gdb.go/basic-types.exp: pt false +PASS: gdb.go/basic-types.exp: pt bool(0) +PASS: gdb.go/basic-types.exp: pt bool(1) +PASS: gdb.go/basic-types.exp: pt 'a' +PASS: gdb.go/basic-types.exp: pt "a simple string" +PASS: gdb.go/basic-types.exp: pt `a simple raw string` +PASS: gdb.go/basic-types.exp: pt .44 +PASS: gdb.go/basic-types.exp: pt 44.0 +PASS: gdb.go/basic-types.exp: pt 10e20 +PASS: gdb.go/basic-types.exp: pt 10E20 +PASS: gdb.go/basic-types.exp: pt float32(.42) +PASS: gdb.go/basic-types.exp: pt float64(.42) +PASS: gdb.go/basic-types.exp: pt complex64(.42) +XFAIL: gdb.go/basic-types.exp: pt complex64(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex64(i1.0) +PASS: gdb.go/basic-types.exp: pt complex128(.42) +XFAIL: gdb.go/basic-types.exp: pt complex128(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex128(i1.0) +Running ./gdb.go/chan.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/chan.exp: chan.exp +Running ./gdb.go/handcall.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/handcall.exp: handcall.exp +Running ./gdb.go/hello.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/hello.exp: hello.exp +Running ./gdb.go/integers.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/integers.exp: integers.exp +Running ./gdb.go/methods.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/methods.exp: methods.exp +Running ./gdb.go/package.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/package.exp: package +Running ./gdb.go/print.exp ... +PASS: gdb.go/print.exp: set language go +PASS: gdb.go/print.exp: set language to "go" +PASS: gdb.go/print.exp: check fp + text +PASS: gdb.go/print.exp: p 1. +PASS: gdb.go/print.exp: p 1.5 +PASS: gdb.go/print.exp: p 1.f +PASS: gdb.go/print.exp: p 1.5f +PASS: gdb.go/print.exp: p 1.l +PASS: gdb.go/print.exp: p 1.5l +PASS: gdb.go/print.exp: p 0x1.1 +PASS: gdb.go/print.exp: reject p 1.1x +PASS: gdb.go/print.exp: reject p 1.1ff +PASS: gdb.go/print.exp: reject p 1.1ll +Running ./gdb.go/strings.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/strings.exp: strings.exp +Running ./gdb.go/types.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/types.exp: types.exp +Running ./gdb.go/unsafe.exp ... +gdb compile failed, default_target_compile: Can't find armv7a-cros-linux-gnueabi-gccgo. +UNTESTED: gdb.go/unsafe.exp: unsafe.exp +Running ./gdb.java/jmain.exp ... +UNSUPPORTED: gdb.java/jmain.exp: compilation jmain.java +Running ./gdb.java/jmisc.exp ... +UNSUPPORTED: gdb.java/jmisc.exp: compilation jmisc.java +Running ./gdb.java/jnpe.exp ... +UNSUPPORTED: gdb.java/jnpe.exp: compilation jnpe.java +UNTESTED: gdb.java/jnpe.exp: Couldn't compile ./gdb.java/jnpe.java +Running ./gdb.java/jprint.exp ... +UNSUPPORTED: gdb.java/jprint.exp: compilation jprint.java +Running ./gdb.java/jv-exp.exp ... +PASS: gdb.java/jv-exp.exp: set print sevenbit-strings +PASS: gdb.java/jv-exp.exp: set width 0 +PASS: gdb.java/jv-exp.exp: set language java +PASS: gdb.java/jv-exp.exp: set language to "java" +PASS: gdb.java/jv-exp.exp: p 1 > 2 +PASS: gdb.java/jv-exp.exp: p 1 < 2 +Running ./gdb.java/jv-print.exp ... +PASS: gdb.java/jv-print.exp: print $pc +PASS: gdb.java/jv-print.exp: set print sevenbit-strings +PASS: gdb.java/jv-print.exp: set width 0 +PASS: gdb.java/jv-print.exp: set language java +PASS: gdb.java/jv-print.exp: set language to "java" +PASS: gdb.java/jv-print.exp: p 123 +PASS: gdb.java/jv-print.exp: p -123 +PASS: gdb.java/jv-print.exp: p/d 123 +PASS: gdb.java/jv-print.exp: p 0123 +PASS: gdb.java/jv-print.exp: p 00123 +PASS: gdb.java/jv-print.exp: p -0123 +PASS: gdb.java/jv-print.exp: p/o 0123 +PASS: gdb.java/jv-print.exp: p 0x123 +PASS: gdb.java/jv-print.exp: p -0x123 +PASS: gdb.java/jv-print.exp: p 0x0123 +PASS: gdb.java/jv-print.exp: p -0x0123 +PASS: gdb.java/jv-print.exp: p 0xABCDEF +PASS: gdb.java/jv-print.exp: p 0xabcdef +PASS: gdb.java/jv-print.exp: p 0xAbCdEf +PASS: gdb.java/jv-print.exp: p/x 0x123 +PASS: gdb.java/jv-print.exp: p 'a' +PASS: gdb.java/jv-print.exp: p/c 'a' +PASS: gdb.java/jv-print.exp: p/c 70 +PASS: gdb.java/jv-print.exp: p/x 'a' +PASS: gdb.java/jv-print.exp: p/d 'a' +PASS: gdb.java/jv-print.exp: p/t 'a' +PASS: gdb.java/jv-print.exp: p/x '\377' +PASS: gdb.java/jv-print.exp: p '\'' +PASS: gdb.java/jv-print.exp: p '\\' +PASS: gdb.java/jv-print.exp: reject p 0x +PASS: gdb.java/jv-print.exp: p '' +PASS: gdb.java/jv-print.exp: p ''' +PASS: gdb.java/jv-print.exp: reject p '\' +PASS: gdb.java/jv-print.exp: reject p '\\\' +PASS: gdb.java/jv-print.exp: reject p DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123foobar.bazfoo3 +PASS: gdb.java/jv-print.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.java/jv-print.exp: check for floating addition +PASS: gdb.java/jv-print.exp: reject p 09 +PASS: gdb.java/jv-print.exp: reject p 079 +PASS: gdb.java/jv-print.exp: reject p 0xG +PASS: gdb.java/jv-print.exp: reject p 0xAG +PASS: gdb.java/jv-print.exp: check fp + text +PASS: gdb.java/jv-print.exp: p 1. +PASS: gdb.java/jv-print.exp: p 1.5 +PASS: gdb.java/jv-print.exp: p 1.f +PASS: gdb.java/jv-print.exp: p 1.5f +PASS: gdb.java/jv-print.exp: p 1.d +PASS: gdb.java/jv-print.exp: p 1.5d +PASS: gdb.java/jv-print.exp: p 0x1.1 +PASS: gdb.java/jv-print.exp: reject p 1.1x +PASS: gdb.java/jv-print.exp: reject p 1.1ff +PASS: gdb.java/jv-print.exp: reject p 1.1dd +Running ./gdb.linespec/break-ask.exp ... +PASS: gdb.linespec/break-ask.exp: set multiple-symbols ask +PASS: gdb.linespec/break-ask.exp: set filename-display absolute +PASS: gdb.linespec/break-ask.exp: break twodup absolute +PASS: gdb.linespec/break-ask.exp: 0 +PASS: gdb.linespec/break-ask.exp: set filename-display relative +PASS: gdb.linespec/break-ask.exp: break twodup relative +PASS: gdb.linespec/break-ask.exp: 2 +PASS: gdb.linespec/break-ask.exp: expect breakpoint +PASS: gdb.linespec/break-ask.exp: info source +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere +PASS: gdb.linespec/break-ask.exp: break twodup relative other +PASS: gdb.linespec/break-ask.exp: 3 +PASS: gdb.linespec/break-ask.exp: expect breakpoint other +PASS: gdb.linespec/break-ask.exp: info source other +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere other +Running ./gdb.linespec/linespec.exp ... +PASS: gdb.linespec/linespec.exp: set multiple-symbols to all for linespec tests +PASS: gdb.linespec/linespec.exp: single-location break using dir/file:line +PASS: gdb.linespec/linespec.exp: clear breakpoint using dir/file:line +PASS: gdb.linespec/linespec.exp: multi-location break using file:line +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name and label +PASS: gdb.linespec/linespec.exp: complete condition +PASS: gdb.linespec/linespec.exp: disable pending breakpoints for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint on non-existent function +PASS: gdb.linespec/linespec.exp: set breakpoint at all instances of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at non-existent lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at specific instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint in body.h +PASS: gdb.linespec/linespec.exp: set breakpoint in f1 +PASS: gdb.linespec/linespec.exp: add inferior for linespec tests +PASS: gdb.linespec/linespec.exp: switch to inferior 2 for linespec tests +PASS: gdb.linespec/linespec.exp: set the new inferior file for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint at main in both inferiors +Running ./gdb.linespec/ls-dollar.exp ... +PASS: gdb.linespec/ls-dollar.exp: set listsize 1 +PASS: gdb.linespec/ls-dollar.exp: list $dollar_var +PASS: gdb.linespec/ls-dollar.exp: break $dollar_func +Running ./gdb.linespec/ls-errs.exp ... +PASS: gdb.linespec/ls-errs.exp: set breakpoint pending off +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break -100 +PASS: gdb.linespec/ls-errs.exp: break +500 +PASS: gdb.linespec/ls-errs.exp: break 1000 +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 1 +PASS: gdb.linespec/ls-errs.exp: break +10 1 +PASS: gdb.linespec/ls-errs.exp: break -10 1 +PASS: gdb.linespec/ls-errs.exp: break 3 +1 +PASS: gdb.linespec/ls-errs.exp: break +10 +1 +PASS: gdb.linespec/ls-errs.exp: break -10 +1 +PASS: gdb.linespec/ls-errs.exp: break 3 +100 +PASS: gdb.linespec/ls-errs.exp: break +10 +100 +PASS: gdb.linespec/ls-errs.exp: break -10 +100 +PASS: gdb.linespec/ls-errs.exp: break 3 -10 +PASS: gdb.linespec/ls-errs.exp: break +10 -10 +PASS: gdb.linespec/ls-errs.exp: break -10 -10 +PASS: gdb.linespec/ls-errs.exp: break 3 foo +PASS: gdb.linespec/ls-errs.exp: break +10 foo +PASS: gdb.linespec/ls-errs.exp: break -10 foo +PASS: gdb.linespec/ls-errs.exp: break this_file_doesn't_exist.c:3 +PASS: gdb.linespec/ls-errs.exp: break this file has spaces.c:3 +PASS: gdb.linespec/ls-errs.exp: break "file::colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'file::colons.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this "file" has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'this "file" has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'this 'file' has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this 'file' has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break "spaces: and :colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'more: :spaces: :and colons::.c':3 +PASS: gdb.linespec/ls-errs.exp: break "src-file.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'src-file.c:3 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 1 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 +100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 -100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:-100 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:-100" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:-100' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:+500 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:+500" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:+500' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:1000 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:1000" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:1000' +PASS: gdb.linespec/ls-errs.exp: break foobar +PASS: gdb.linespec/ls-errs.exp: break foo::bar +PASS: gdb.linespec/ls-errs.exp: break foo.bar +PASS: gdb.linespec/ls-errs.exp: break foo . +PASS: gdb.linespec/ls-errs.exp: break foo bar +PASS: gdb.linespec/ls-errs.exp: break foo 1 +PASS: gdb.linespec/ls-errs.exp: break foo 0 +PASS: gdb.linespec/ls-errs.exp: break foo +10 +PASS: gdb.linespec/ls-errs.exp: break foo -10 +PASS: gdb.linespec/ls-errs.exp: break foo +100 +PASS: gdb.linespec/ls-errs.exp: break foo -100 +PASS: gdb.linespec/ls-errs.exp: break main:there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main: there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main :there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main 3 +PASS: gdb.linespec/ls-errs.exp: break main +100 +PASS: gdb.linespec/ls-errs.exp: break main -100 +PASS: gdb.linespec/ls-errs.exp: break main foo +PASS: gdb.linespec/ls-errs.exp: break main:here 3 +PASS: gdb.linespec/ls-errs.exp: break main:here +100 +PASS: gdb.linespec/ls-errs.exp: break main:here -100 +PASS: gdb.linespec/ls-errs.exp: break main:here foo +PASS: gdb.linespec/ls-errs.exp: break if +PASS: gdb.linespec/ls-errs.exp: break task +PASS: gdb.linespec/ls-errs.exp: break thread +PASS: gdb.linespec/ls-errs.exp: break 'main.c'flubber +PASS: gdb.linespec/ls-errs.exp: break 'main.c',21 +PASS: gdb.linespec/ls-errs.exp: break 'main.c' +PASS: gdb.linespec/ls-errs.exp: break 'main.c'3 +PASS: gdb.linespec/ls-errs.exp: break 'main.c'+3 +PASS: gdb.linespec/ls-errs.exp: break $zippo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:$zippo +Running ./gdb.linespec/macro-relative.exp ... +FAIL: gdb.linespec/macro-relative.exp: info macro HEADER +Running ./gdb.linespec/skip-two.exp ... +PASS: gdb.linespec/skip-two.exp: skip function dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored from main +PASS: gdb.linespec/skip-two.exp: continue to breakpoint: n +PASS: gdb.linespec/skip-two.exp: dupname ignored from n +PASS: gdb.linespec/skip-two.exp: skip delete 1 +PASS: gdb.linespec/skip-two.exp: skip file thefile.cc +PASS: gdb.linespec/skip-two.exp: step into dupname +PASS: gdb.linespec/skip-two.exp: finish from dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored for thefile.cc +Running ./gdb.linespec/thread.exp ... +PASS: gdb.linespec/thread.exp: breakpoint line number in file +PASS: gdb.linespec/thread.exp: continue to breakpoint: 29 +PASS: gdb.linespec/thread.exp: setting breakpoint at thread +PASS: gdb.linespec/thread.exp: continue to breakpoint: thread function +Running ./gdb.mi/dw2-ref-missing-frame.exp ... +PASS: gdb.mi/dw2-ref-missing-frame.exp: breakpoint at func_nofb_marker +PASS: gdb.mi/dw2-ref-missing-frame.exp: mi runto func_nofb_marker +PASS: gdb.mi/dw2-ref-missing-frame.exp: test func_nofb_marker +PASS: gdb.mi/dw2-ref-missing-frame.exp: breakpoint at func_loopfb_marker +PASS: gdb.mi/dw2-ref-missing-frame.exp: mi runto func_loopfb_marker +PASS: gdb.mi/dw2-ref-missing-frame.exp: test func_loopfb_var +Running ./gdb.mi/gdb2549.exp ... +PASS: gdb.mi/gdb2549.exp: wrong arguments +PASS: gdb.mi/gdb2549.exp: no executable +PASS: gdb.mi/gdb2549.exp: breakpoint at main +PASS: gdb.mi/gdb2549.exp: mi runto main +PASS: gdb.mi/gdb2549.exp: register values x +PASS: gdb.mi/gdb2549.exp: register values f +PASS: gdb.mi/gdb2549.exp: register values d +PASS: gdb.mi/gdb2549.exp: register values o +PASS: gdb.mi/gdb2549.exp: register values t +Running ./gdb.mi/gdb669.exp ... +PASS: gdb.mi/gdb669.exp: successfully compiled posix threads test case +PASS: gdb.mi/gdb669.exp: breakpoint at main +PASS: gdb.mi/gdb669.exp: mi runto main +PASS: gdb.mi/gdb669.exp: -thread-list-ids (at main) +PASS: gdb.mi/gdb669.exp: info threads (at main) +PASS: gdb.mi/gdb669.exp: finding MI result string (at main) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (at main) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (at main) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (at main) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (at main) +PASS: gdb.mi/gdb669.exp: next, try 0 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 0) +PASS: gdb.mi/gdb669.exp: info threads (try 0) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 0) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 0) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 0) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 0) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 0) +PASS: gdb.mi/gdb669.exp: next, try 1 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 1) +PASS: gdb.mi/gdb669.exp: info threads (try 1) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 1) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 1) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 1) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 1) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 1) +PASS: gdb.mi/gdb669.exp: next, try 2 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 2) +PASS: gdb.mi/gdb669.exp: info threads (try 2) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 2) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 2) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 2) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 2) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 2) +PASS: gdb.mi/gdb669.exp: next, try 3 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 3) +PASS: gdb.mi/gdb669.exp: info threads (try 3) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 3) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 3) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 3) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 3) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 3) +Running ./gdb.mi/gdb680.exp ... +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 0 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 1 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 2 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 3 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 4 +Running ./gdb.mi/gdb701.exp ... +PASS: gdb.mi/gdb701.exp: breakpoint at main +PASS: gdb.mi/gdb701.exp: mi runto main +PASS: gdb.mi/gdb701.exp: step over "foo = 0" +PASS: gdb.mi/gdb701.exp: create fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr.x +PASS: gdb.mi/gdb701.exp: list children of fooPtr.y +PASS: gdb.mi/gdb701.exp: list children of fooPtr.z +Running ./gdb.mi/gdb792.exp ... +PASS: gdb.mi/gdb792.exp: breakpoint at main +PASS: gdb.mi/gdb792.exp: mi runto main +PASS: gdb.mi/gdb792.exp: create var for class A +PASS: gdb.mi/gdb792.exp: list children of class A +PASS: gdb.mi/gdb792.exp: list children of A.public +PASS: gdb.mi/gdb792.exp: list children of A.private +PASS: gdb.mi/gdb792.exp: list children of A.protected +PASS: gdb.mi/gdb792.exp: list children of A.protected.b +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.public +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.private +PASS: gdb.mi/gdb792.exp: create var for class C which has baseclass A +PASS: gdb.mi/gdb792.exp: list children of class C +Running ./gdb.mi/mi2-amd64-entry-value.exp ... +Running ./gdb.mi/mi2-prompt.exp ... +PASS: gdb.mi/mi2-prompt.exp: console set prompt +PASS: gdb.mi/mi2-prompt.exp: -break-list +PASS: gdb.mi/mi2-prompt.exp: set prompt (banana) +PASS: gdb.mi/mi2-prompt.exp: interpreter-exec mi -break-list +Running ./gdb.mi/mi2-var-child.exp ... +PASS: gdb.mi/mi2-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi2-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi2-var-child.exp: run to 237 (set breakpoint) +PASS: gdb.mi/mi2-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi2-var-child.exp: create local variable weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: is weird editable +PASS: gdb.mi/mi2-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi2-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi2-var-child.exp: delete var weird +PASS: gdb.mi/mi2-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi2-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi2-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi2-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: break in do_anonymous_type_tests +PASS: gdb.mi/mi2-var-child.exp: continue to do_anonymous_type_tests breakpoint +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for v +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3 +PASS: gdb.mi/mi2-var-child.exp: expression for v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous.b +Running ./gdb.mi/mi-async.exp ... +Running ./gdb.mi/mi-basics.exp ... +PASS: gdb.mi/mi-basics.exp: acceptance of MI operations +PASS: gdb.mi/mi-basics.exp: file-exec-and-symbols operation +PASS: gdb.mi/mi-basics.exp: file-exec-file operation +PASS: gdb.mi/mi-basics.exp: file-symbol-file operation +PASS: gdb.mi/mi-basics.exp: break-delete (all) operation +PASS: gdb.mi/mi-basics.exp: all breakpoints removed +PASS: gdb.mi/mi-basics.exp: environment-directory arg operation +PASS: gdb.mi/mi-basics.exp: environment-directory empty-string operation +PASS: gdb.mi/mi-basics.exp: environment-directory operation +PASS: gdb.mi/mi-basics.exp: environment-cd arg operation +PASS: gdb.mi/mi-basics.exp: environment-pwd operation +PASS: gdb.mi/mi-basics.exp: environment-path +PASS: gdb.mi/mi-basics.exp: environment-path no-args operation +PASS: gdb.mi/mi-basics.exp: environment-path dir1 dir2 operation +PASS: gdb.mi/mi-basics.exp: environment-path -r dir operation +PASS: gdb.mi/mi-basics.exp: environment-path -r operation +PASS: gdb.mi/mi-basics.exp: initial tty is mi_inferior_tty_name +PASS: gdb.mi/mi-basics.exp: set tty to /dev/pts/1 +PASS: gdb.mi/mi-basics.exp: tty was set correctly +PASS: gdb.mi/mi-basics.exp: set tty to the empty string +PASS: gdb.mi/mi-basics.exp: make sure tty is empty +PASS: gdb.mi/mi-basics.exp: set tty to mi_inferior_tty_name (the way it was) +PASS: gdb.mi/mi-basics.exp: verify tty is correct +Running ./gdb.mi/mi-break.exp ... +PASS: gdb.mi/mi-break.exp: break-insert -t operation +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-break.exp: list of breakpoints +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +KFAIL: gdb.mi/mi-break.exp: break-insert -r operation (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee2 (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp .*llee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: list of breakpoints (PRMS: mi/14270) +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +PASS: gdb.mi/mi-break.exp: insert breakpoint with ignore count at callme +PASS: gdb.mi/mi-break.exp: run to breakpoint with ignore count +PASS: gdb.mi/mi-break.exp: breakpoint at nonexistent function +PASS: gdb.mi/mi-break.exp: create varobj for function call +PASS: gdb.mi/mi-break.exp: update varobj for function call +PASS: gdb.mi/mi-break.exp: test disabled creation +PASS: gdb.mi/mi-break.exp: test disabled creation: cleanup +PASS: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: breakpoint commands: set commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are set +PASS: gdb.mi/mi-break.exp: breakpoint commands: clear commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are cleared +FAIL: gdb.mi/mi-break.exp: breakpoint at main +FAIL: gdb.mi/mi-break.exp: mi runto main (unknown output after running) +FAIL: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2, again +FAIL: gdb.mi/mi-break.exp: breakpoint commands: set commands +FAIL: gdb.mi/mi-break.exp: breakpoint commands: continue (MI error) +FAIL: gdb.mi/mi-break.exp: intermediate stop and continue +FAIL: gdb.mi/mi-break.exp: test hitting breakpoint with commands (unknown output after running) +PASS: gdb.mi/mi-break.exp: create local variable tpnum +PASS: gdb.mi/mi-break.exp: eval tpnum before tracepoint +FAIL: gdb.mi/mi-break.exp: break-insert -a operation +PASS: gdb.mi/mi-break.exp: update tpnum +FAIL: gdb.mi/mi-break.exp: eval tpnum after tracepoint +Running ./gdb.mi/mi-breakpoint-changed.exp ... +PASS: gdb.mi/mi-breakpoint-changed.exp: breakpoint at main +FAIL: gdb.mi/mi-breakpoint-changed.exp: mi runto main (unknown output after running) +PASS: gdb.mi/mi-breakpoint-changed.exp: change command +PASS: gdb.mi/mi-breakpoint-changed.exp: watch watch +PASS: gdb.mi/mi-breakpoint-changed.exp: trace marker +FAIL: gdb.mi/mi-breakpoint-changed.exp: catch syscall +FAIL: gdb.mi/mi-breakpoint-changed.exp: dprintf marker, "arg" " +PASS: gdb.mi/mi-breakpoint-changed.exp: condition 2 main > 0x0 +PASS: gdb.mi/mi-breakpoint-changed.exp: disable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: enable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: ignore 5 1 +PASS: gdb.mi/mi-breakpoint-changed.exp: passcount 1 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 5 +FAIL: gdb.mi/mi-breakpoint-changed.exp: delete 6 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc1 +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc1 resolved +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to pendfunc1 breakpoint (timeout) +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: delete breakpoint on pendfunc1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on marker +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc3 +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 1 (MI error) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 1 (timeout) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continuing execution to marker (MI error) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 resolved (timeout) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 2 (timeout) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continuing to exit (MI error) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 pending again (timeout) +FAIL: gdb.mi/mi-breakpoint-changed.exp: pending resolved: (unknown output after running) +Running ./gdb.mi/mi-catch-load.exp ... +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-load: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-load: catch load +FAIL: gdb.mi/mi-catch-load.exp: catch-load: solib-event stop +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-unload: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-unload: catch unload +FAIL: gdb.mi/mi-catch-load.exp: catch-unload: solib-event stop +Running ./gdb.mi/mi-cli.exp ... +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with no arguments +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with one argument +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with bogus interpreter +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console bogus +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "file $binfile" +PASS: gdb.mi/mi-cli.exp: breakpoint at main +PASS: gdb.mi/mi-cli.exp: mi runto main +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set args foobar" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "show args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "break callee4" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "info break" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set listsize 1" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" +PASS: gdb.mi/mi-cli.exp: continue to callee4 +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "delete 2" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "up" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "down" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "frame 2" +PASS: gdb.mi/mi-cli.exp: -stack-select-frame 0 +PASS: gdb.mi/mi-cli.exp: check *stopped from CLI command +PASS: gdb.mi/mi-cli.exp: -break-insert -t basics.c:$line_main_hello +PASS: gdb.mi/mi-cli.exp: -exec-continue to line $line_main_hello +PASS: gdb.mi/mi-cli.exp: 34 next: run +PASS: gdb.mi/mi-cli.exp: 34 next: stop +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" at basics.c:$line_main_return +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "help set args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set $pc=0x0" +Running ./gdb.mi/mi-cmd-param-changed.exp ... +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: breakpoint at main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: mi runto main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" no event (requested by MI) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" no event (requested by MI interp) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking stepr" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set ch type on" +Running ./gdb.mi/mi-console.exp ... +PASS: gdb.mi/mi-console.exp: breakpoint at main +PASS: gdb.mi/mi-console.exp: mi runto main +PASS: gdb.mi/mi-console.exp: Testing console output +UNSUPPORTED: gdb.mi/mi-console.exp: Testing console output inferior output +PASS: gdb.mi/mi-console.exp: finished step over hello +Running ./gdb.mi/mi-disassemble.exp ... +PASS: gdb.mi/mi-disassemble.exp: breakpoint at main +PASS: gdb.mi/mi-disassemble.exp: mi runto main +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus filename +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus address +PASS: gdb.mi/mi-disassemble.exp: data-disassemble mix different args +PASS: gdb.mi/mi-disassemble.exp: data-disassemble wrong mode arg +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly mixed +Running ./gdb.mi/mi-eval.exp ... +PASS: gdb.mi/mi-eval.exp: breakpoint at callee4 +PASS: gdb.mi/mi-eval.exp: mi runto callee4 +PASS: gdb.mi/mi-eval.exp: next at callee4 +PASS: gdb.mi/mi-eval.exp: eval A +PASS: gdb.mi/mi-eval.exp: eval &A +PASS: gdb.mi/mi-eval.exp: eval A+3 +PASS: gdb.mi/mi-eval.exp: eval A + 3 +Running ./gdb.mi/mi-file.exp ... +PASS: gdb.mi/mi-file.exp: request path info of current source file (basics.c) +PASS: gdb.mi/mi-file.exp: Getting a list of source files. +Running ./gdb.mi/mi-file-transfer.exp ... +FAIL: gdb.mi/mi-file-transfer.exp: put binary file +FAIL: gdb.mi/mi-file-transfer.exp: get binary file +FAIL: gdb.mi/mi-file-transfer.exp: compare binary file +FAIL: gdb.mi/mi-file-transfer.exp: deleted binary file +Running ./gdb.mi/mi-fill-memory.exp ... +PASS: gdb.mi/mi-fill-memory.exp: breakpoint at main +PASS: gdb.mi/mi-fill-memory.exp: mi runto main +PASS: gdb.mi/mi-fill-memory.exp: next at main +PASS: gdb.mi/mi-fill-memory.exp: no arguments +PASS: gdb.mi/mi-fill-memory.exp: one argument missing +PASS: gdb.mi/mi-fill-memory.exp: memory successfully written +PASS: gdb.mi/mi-fill-memory.exp: memory successfully filled (8 bytes) +PASS: gdb.mi/mi-fill-memory.exp: pattern correctly read from memory +Running ./gdb.mi/mi-fullname-deleted.exp ... +PASS: gdb.mi/mi-fullname-deleted.exp: set substitute-path +PASS: gdb.mi/mi-fullname-deleted.exp: fullname present +PASS: gdb.mi/mi-fullname-deleted.exp: substituted fullname +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does not match +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does match +Running ./gdb.mi/mi-hack-cli.exp ... +PASS: gdb.mi/mi-hack-cli.exp: show architecture +PASS: gdb.mi/mi-hack-cli.exp: 47show architecture +Running ./gdb.mi/mi-info-os.exp ... +FAIL: gdb.mi/mi-info-os.exp: -info-os +Running ./gdb.mi/mi-inheritance-syntax-error.exp ... +PASS: gdb.mi/mi-inheritance-syntax-error.exp: breakpoint at C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: mi runto C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: create var for THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: list children of THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -var-info-path-expression var1.A +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -data-evaluate-expression (*(class A*) this) +Running ./gdb.mi/mi-logging.exp ... +PASS: gdb.mi/mi-logging.exp: breakpoint at main +PASS: gdb.mi/mi-logging.exp: mi runto main +PASS: gdb.mi/mi-logging.exp: logging on +PASS: gdb.mi/mi-logging.exp: logged step +PASS: gdb.mi/mi-logging.exp: logged next +PASS: gdb.mi/mi-logging.exp: logging off +PASS: gdb.mi/mi-logging.exp: Log file contents +PASS: gdb.mi/mi-logging.exp: redirect logging on +PASS: gdb.mi/mi-logging.exp: redirect logging off +PASS: gdb.mi/mi-logging.exp: Redirect log file contents +Running ./gdb.mi/mi-memory-changed.exp ... +PASS: gdb.mi/mi-memory-changed.exp: insert breakpoint +PASS: gdb.mi/mi-memory-changed.exp: continue to callee4 +PASS: gdb.mi/mi-memory-changed.exp: set var C = 4 +PASS: gdb.mi/mi-memory-changed.exp: create objvar for C +PASS: gdb.mi/mi-memory-changed.exp: change C thru. varobj +PASS: gdb.mi/mi-memory-changed.exp: change C thru. -data-write-memory-bytes +PASS: gdb.mi/mi-memory-changed.exp: get address of main +Running ./gdb.mi/mi-nonstop-exit.exp ... +PASS: gdb.mi/mi-nonstop-exit.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue (2) +Running ./gdb.mi/mi-nonstop.exp ... +PASS: gdb.mi/mi-nonstop.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop.exp: mi runto main +PASS: gdb.mi/mi-nonstop.exp: breakpoint at marker +PASS: gdb.mi/mi-nonstop.exp: w0,i0 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i0 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 1 +PASS: gdb.mi/mi-nonstop.exp: select thread 2 +PASS: gdb.mi/mi-nonstop.exp: create varobj in first thread +PASS: gdb.mi/mi-nonstop.exp: select thread 3 +PASS: gdb.mi/mi-nonstop.exp: create varobj in second thread +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 2 +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 2 +PASS: gdb.mi/mi-nonstop.exp: w1,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 3 +PASS: gdb.mi/mi-nonstop.exp: update varobj, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w0, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: interrupted +PASS: gdb.mi/mi-nonstop.exp: got interrupt +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 4 +PASS: gdb.mi/mi-nonstop.exp: resume all +PASS: gdb.mi/mi-nonstop.exp: w0,i2 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i2 stop +PASS: gdb.mi/mi-nonstop.exp: set condition, 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i3 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop on cond breakpoint +PASS: gdb.mi/mi-nonstop.exp: update varobj, 2 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: stacktrace of running thread +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +PASS: gdb.mi/mi-nonstop.exp: select first worker thread +PASS: gdb.mi/mi-nonstop.exp: ask the second thread to exit +UNSUPPORTED: gdb.mi/mi-nonstop.exp: wait for thread exit +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +Running ./gdb.mi/mi-nsintrall.exp ... +PASS: gdb.mi/mi-nsintrall.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at main +PASS: gdb.mi/mi-nsintrall.exp: mi runto main +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsintrall.exp: stop 0 +PASS: gdb.mi/mi-nsintrall.exp: stop 1 +PASS: gdb.mi/mi-nsintrall.exp: stop 2 +PASS: gdb.mi/mi-nsintrall.exp: stop 3 +PASS: gdb.mi/mi-nsintrall.exp: stop 4 +PASS: gdb.mi/mi-nsintrall.exp: stop 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all stopped +PASS: gdb.mi/mi-nsintrall.exp: resume all, no breakpoint +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all +PASS: gdb.mi/mi-nsintrall.exp: interrupt all threads +PASS: gdb.mi/mi-nsintrall.exp: interrupt 0 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 1 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 2 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 3 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 4 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all interrupted +PASS: gdb.mi/mi-nsintrall.exp: resume all after interrupting +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all after interrupting +Running ./gdb.mi/mi-nsmoribund.exp ... +PASS: gdb.mi/mi-nsmoribund.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at main +PASS: gdb.mi/mi-nsmoribund.exp: mi runto main +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: stop 0 +PASS: gdb.mi/mi-nsmoribund.exp: stop 1 +PASS: gdb.mi/mi-nsmoribund.exp: stop 2 +PASS: gdb.mi/mi-nsmoribund.exp: stop 3 +PASS: gdb.mi/mi-nsmoribund.exp: stop 4 +PASS: gdb.mi/mi-nsmoribund.exp: stop 5 +PASS: gdb.mi/mi-nsmoribund.exp: stop 6 +PASS: gdb.mi/mi-nsmoribund.exp: stop 7 +PASS: gdb.mi/mi-nsmoribund.exp: stop 8 +PASS: gdb.mi/mi-nsmoribund.exp: stop 9 +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all stopped except the main thread +PASS: gdb.mi/mi-nsmoribund.exp: select thread 5 +PASS: gdb.mi/mi-nsmoribund.exp: thread specific breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: resume all, thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: hit thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all running except the breakpoint thread +PASS: gdb.mi/mi-nsmoribund.exp: resume all, program exited normally +Running ./gdb.mi/mi-ns-stale-regcache.exp ... +PASS: gdb.mi/mi-ns-stale-regcache.exp: breakpoint at main +PASS: gdb.mi/mi-ns-stale-regcache.exp: mi runto main +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale register cache of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale frame info of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: main thread still running +Running ./gdb.mi/mi-nsthrexec.exp ... +Running ./gdb.mi/mi-pending.exp ... +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on pendfunc1 +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on mi-pendshr.c:pendfunc2 if x==4 +FAIL: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 (unknown output after running) +FAIL: gdb.mi/mi-pending.exp: continuing execution to skip conditional bp (MI error) +FAIL: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 a second time (timeout) +FAIL: gdb.mi/mi-pending.exp: continuing execution to conditional bp (MI error) +FAIL: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc2 with x==4 (timeout) +Running ./gdb.mi/mi-pthreads.exp ... +PASS: gdb.mi/mi-pthreads.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-pthreads.exp: breakpoint at done_making_threads +PASS: gdb.mi/mi-pthreads.exp: mi runto done_making_threads +PASS: gdb.mi/mi-pthreads.exp: -thread_list_ids (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: finding threads in MI output (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 123456789 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 6 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 5 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 4 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 3 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 2 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 1 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 6 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 5 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 4 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 3 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 2 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 1 +Running ./gdb.mi/mi-read-memory.exp ... +PASS: gdb.mi/mi-read-memory.exp: breakpoint at main +PASS: gdb.mi/mi-read-memory.exp: mi runto main +PASS: gdb.mi/mi-read-memory.exp: next at main +PASS: gdb.mi/mi-read-memory.exp: no arguments +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte offset by -6 +PASS: gdb.mi/mi-read-memory.exp: expression in quotes +PASS: gdb.mi/mi-read-memory.exp: ascii and data +PASS: gdb.mi/mi-read-memory.exp: decimal +PASS: gdb.mi/mi-read-memory.exp: octal +Running ./gdb.mi/mi-record-changed.exp ... +Running ./gdb.mi/mi-regs.exp ... +Running ./gdb.mi/mi-return.exp ... +PASS: gdb.mi/mi-return.exp: breakpoint at callee4 +PASS: gdb.mi/mi-return.exp: mi runto callee4 +PASS: gdb.mi/mi-return.exp: delete all breakpoints +PASS: gdb.mi/mi-return.exp: return from callee4 now +Running ./gdb.mi/mi-reverse.exp ... +Running ./gdb.mi/mi-simplerun.exp ... +PASS: gdb.mi/mi-simplerun.exp: break-insert operation +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints +PASS: gdb.mi/mi-simplerun.exp: disabling of breakpoints +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints, 16 disabled +PASS: gdb.mi/mi-simplerun.exp: run to main +PASS: gdb.mi/mi-simplerun.exp: next at main +PASS: gdb.mi/mi-simplerun.exp: step at main +PASS: gdb.mi/mi-simplerun.exp: step to callee4 +PASS: gdb.mi/mi-simplerun.exp: exec-finish +PASS: gdb.mi/mi-simplerun.exp: continue to end +Running ./gdb.mi/mi-solib.exp ... +PASS: gdb.mi/mi-solib.exp: set stop-on-solib-events +FAIL: gdb.mi/mi-solib.exp: check for solib event (unknown output after running) +Running ./gdb.mi/mi-stack.exp ... +PASS: gdb.mi/mi-stack.exp: breakpoint at callee4 +PASS: gdb.mi/mi-stack.exp: mi runto callee4 +PASS: gdb.mi/mi-stack.exp: stack frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 1 +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 3 +PASS: gdb.mi/mi-stack.exp: stack frame listing wrong +PASS: gdb.mi/mi-stack.exp: selected frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 300 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing wrong +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 300 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names +PASS: gdb.mi/mi-stack.exp: next's in callee4 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names and values +PASS: gdb.mi/mi-stack.exp: stack locals listing, simple types: names and values, complex type: names and types +PASS: gdb.mi/mi-stack.exp: stack locals listing wrong +PASS: gdb.mi/mi-stack.exp: stack select frame 1 +PASS: gdb.mi/mi-stack.exp: stack locals listing for new frame +PASS: gdb.mi/mi-stack.exp: stack locals for same frame (level 1) +PASS: gdb.mi/mi-stack.exp: stack info-depth +PASS: gdb.mi/mi-stack.exp: stack info-depth 3 +PASS: gdb.mi/mi-stack.exp: stack info-depth 99 +PASS: gdb.mi/mi-stack.exp: stack info-depth wrong usage +Running ./gdb.mi/mi-stepi.exp ... +PASS: gdb.mi/mi-stepi.exp: breakpoint at main +PASS: gdb.mi/mi-stepi.exp: mi runto main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main +PASS: gdb.mi/mi-stepi.exp: next-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 (line check) +Running ./gdb.mi/mi-stepn.exp ... +PASS: gdb.mi/mi-stepn.exp: breakpoint at main +PASS: gdb.mi/mi-stepn.exp: mi runto main +PASS: gdb.mi/mi-stepn.exp: breakpoint at do_nothing +PASS: gdb.mi/mi-stepn.exp: breakpoint-hit reported +Running ./gdb.mi/mi-syn-frame.exp ... +PASS: gdb.mi/mi-syn-frame.exp: breakpoint at main +PASS: gdb.mi/mi-syn-frame.exp: mi runto main +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint foo +PASS: gdb.mi/mi-syn-frame.exp: call inferior's function with a breakpoint set in it +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function stopped at bp, showing gdb dummy frame +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint subroutine +PASS: gdb.mi/mi-syn-frame.exp: data evaluate expression +FAIL: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: call inferior function which raises exception +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function at exception +Running ./gdb.mi/mi-until.exp ... +PASS: gdb.mi/mi-until.exp: break-insert operation +PASS: gdb.mi/mi-until.exp: run to main +PASS: gdb.mi/mi-until.exp: break-delete 1 +KFAIL: gdb.mi/mi-until.exp: until after while loop (stopped at wrong place) (PRMS: gdb/2104) +PASS: gdb.mi/mi-until.exp: until line number +PASS: gdb.mi/mi-until.exp: until line number:file +PASS: gdb.mi/mi-until.exp: until after current function +Running ./gdb.mi/mi-var-block.exp ... +PASS: gdb.mi/mi-var-block.exp: breakpoint at do_block_tests +PASS: gdb.mi/mi-var-block.exp: mi runto do_block_tests +PASS: gdb.mi/mi-var-block.exp: create local variable cb +PASS: gdb.mi/mi-var-block.exp: try to create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 1 +PASS: gdb.mi/mi-var-block.exp: delete var foo 1 +PASS: gdb.mi/mi-var-block.exp: create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 2 +PASS: gdb.mi/mi-var-block.exp: update all vars: cb foo changed +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 3 +PASS: gdb.mi/mi-var-block.exp: create local variable inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 4 +PASS: gdb.mi/mi-var-block.exp: create local variable foo2 +XFAIL: gdb.mi/mi-var-block.exp: update inner_foo: should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: evaluate inner_foo: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update foo: did not change +PASS: gdb.mi/mi-var-block.exp: delete var inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 5 +XFAIL: gdb.mi/mi-var-block.exp: update foo2: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 6 +XFAIL: gdb.mi/mi-var-block.exp: update foo2 should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: update foo should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update cb +PASS: gdb.mi/mi-var-block.exp: delete var foo 2 +PASS: gdb.mi/mi-var-block.exp: delete var foo2 +PASS: gdb.mi/mi-var-block.exp: delete var cb +Running ./gdb.mi/mi-var-child.exp ... +PASS: gdb.mi/mi-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi-var-child.exp: run to 215 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi-var-child.exp: create local variable weird +PASS: gdb.mi/mi-var-child.exp: get children of weird +PASS: gdb.mi/mi-var-child.exp: get number of children of weird +PASS: gdb.mi/mi-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: is weird editable +PASS: gdb.mi/mi-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi-var-child.exp: delete var weird +PASS: gdb.mi/mi-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.10 changed, don't print values. +PASS: gdb.mi/mi-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.11 changed, print values. +PASS: gdb.mi/mi-var-child.exp: listing of names and values of children +PASS: gdb.mi/mi-var-child.exp: listing of children, simple types: names, type and values, complex types: names and types +PASS: gdb.mi/mi-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: run to mi-var-child.c:323 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create varobj for s +PASS: gdb.mi/mi-var-child.exp: list children of S +PASS: gdb.mi/mi-var-child.exp: delete S.a +PASS: gdb.mi/mi-var-child.exp: delete S.b +PASS: gdb.mi/mi-var-child.exp: delete S +Running ./gdb.mi/mi-var-child-f.exp ... +UNSUPPORTED: gdb.mi/mi-var-child-f.exp: compilation array.f +Running ./gdb.mi/mi-var-cmd.exp ... +PASS: gdb.mi/mi-var-cmd.exp: create global variable +PASS: gdb.mi/mi-var-cmd.exp: create non-existent variable +PASS: gdb.mi/mi-var-cmd.exp: create out of scope variable +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: run to 148 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create local variable linteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpinteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable llong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lplong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable ldouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpdouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable func +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: create lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: create int +PASS: gdb.mi/mi-var-cmd.exp: update all vars +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_test +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (2) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (3) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (4) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (5) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: many changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (6) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: func and lpsimple changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (7) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lsimple and others changed +PASS: gdb.mi/mi-var-cmd.exp: assign to global_simple +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger again, same value +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger not changed after same assign +PASS: gdb.mi/mi-var-cmd.exp: eval linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: update all vars: no changes on second update +PASS: gdb.mi/mi-var-cmd.exp: eval lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lcharacter +PASS: gdb.mi/mi-var-cmd.exp: eval lcharacter +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: eval llong +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: eval lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: eval lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lpfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to ldouble +PASS: gdb.mi/mi-var-cmd.exp: assign to func +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: var update +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func (update) +PASS: gdb.mi/mi-var-cmd.exp: create global variable array_ptr +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: mi runto subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: create i +PASS: gdb.mi/mi-var-cmd.exp: create l +PASS: gdb.mi/mi-var-cmd.exp: create linteger +FAIL: gdb.mi/mi-var-cmd.exp: step at subroutine1 (stopped at wrong place) +XFAIL: gdb.mi/mi-var-cmd.exp: update all vars: changed FIXME +FAIL: gdb.mi/mi-var-cmd.exp: step at subroutine1 (2) (stopped at wrong place) +FAIL: gdb.mi/mi-var-cmd.exp: update all vars: i changed +FAIL: gdb.mi/mi-var-cmd.exp: step at subroutine1 (3) (stopped at wrong place) +FAIL: gdb.mi/mi-var-cmd.exp: update all vars: llong changed +FAIL: gdb.mi/mi-var-cmd.exp: next out of subroutine1 (stopped at wrong place) +FAIL: gdb.mi/mi-var-cmd.exp: update all vars: all now out of scope +PASS: gdb.mi/mi-var-cmd.exp: delete var +PASS: gdb.mi/mi-var-cmd.exp: delete var linteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lpinteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var llong +PASS: gdb.mi/mi-var-cmd.exp: delete var lplong +PASS: gdb.mi/mi-var-cmd.exp: delete var lfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var lpfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var ldouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lpdouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var lpsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var func +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: delete var i +PASS: gdb.mi/mi-var-cmd.exp: delete var l +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: create selected_a +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-cmd.exp: mi runto incr_a +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in incr_a +PASS: gdb.mi/mi-var-cmd.exp: step a line in incr_a +PASS: gdb.mi/mi-var-cmd.exp: return from incr_a to do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: floating varobj invalidation +PASS: gdb.mi/mi-var-cmd.exp: delete selected_a +PASS: gdb.mi/mi-var-cmd.exp: delete array_ptr +FAIL: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:351 (set breakpoint) +FAIL: gdb.mi/mi-var-cmd.exp: wait for stop (frozen: step to 351) +FAIL: gdb.mi/mi-var-cmd.exp: frozen: go to line 351 +FAIL: gdb.mi/mi-var-cmd.exp: frozen: step over 351 (MI error) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:510 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create varobj for Data +PASS: gdb.mi/mi-var-cmd.exp: list children of Data +PASS: gdb.mi/mi-var-cmd.exp: access bitfield +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:453 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create floating varobj +PASS: gdb.mi/mi-var-cmd.exp: update F (1) +PASS: gdb.mi/mi-var-cmd.exp: check F (1) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:464 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (2) +PASS: gdb.mi/mi-var-cmd.exp: check F (2) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:472 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (--all-values) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:478 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (3) +PASS: gdb.mi/mi-var-cmd.exp: check F (3) +PASS: gdb.mi/mi-var-cmd.exp: inside breakpoint inside callee +PASS: gdb.mi/mi-var-cmd.exp: continue to where i is initialized +PASS: gdb.mi/mi-var-cmd.exp: update F inside callee +PASS: gdb.mi/mi-var-cmd.exp: check F inside callee +PASS: gdb.mi/mi-var-cmd.exp: create null_ptr +PASS: gdb.mi/mi-var-cmd.exp: update null_ptr +PASS: gdb.mi/mi-var-cmd.exp: delete null_ptr +PASS: gdb.mi/mi-var-cmd.exp: kill program before endvar +PASS: gdb.mi/mi-var-cmd.exp: create endvar +PASS: gdb.mi/mi-var-cmd.exp: update endvar +PASS: gdb.mi/mi-var-cmd.exp: delete endvar +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: create varobj +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: check initial value +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at main +PASS: gdb.mi/mi-var-cmd.exp: mi runto main +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now, not changed +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now, not changed +Running ./gdb.mi/mi-var-cp.exp ... +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:20 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rx +PASS: gdb.mi/mi-var-cp.exp: update RX (1) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 167 +PASS: gdb.mi/mi-var-cp.exp: update RX (2) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 567 +PASS: gdb.mi/mi-var-cp.exp: update RX (3) +PASS: gdb.mi/mi-var-cp.exp: delete RX +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:46 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s.public +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.i +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.j +PASS: gdb.mi/mi-var-cp.exp: delete S2 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:82 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rptr_s +PASS: gdb.mi/mi-var-cp.exp: list public child of RPTR +PASS: gdb.mi/mi-var-cp.exp: list children of reference to pointer +PASS: gdb.mi/mi-var-cp.exp: check i member +PASS: gdb.mi/mi-var-cp.exp: check j member +PASS: gdb.mi/mi-var-cp.exp: delete RPTR +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:105 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: check attributes of S +PASS: gdb.mi/mi-var-cp.exp: check attributes of R +PASS: gdb.mi/mi-var-cp.exp: -var-update should not list structure varobjs +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:145 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for ip +PASS: gdb.mi/mi-var-cp.exp: list children of IP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression IP.*ip +PASS: gdb.mi/mi-var-cp.exp: create varobj for dp +PASS: gdb.mi/mi-var-cp.exp: list children of DP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public.i +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1.public.i +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public +PASS: gdb.mi/mi-var-cp.exp: create varobj for d +PASS: gdb.mi/mi-var-cp.exp: list children of D +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression D.Base1 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:192 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for array +PASS: gdb.mi/mi-var-cp.exp: list children of A +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression A.2 +PASS: gdb.mi/mi-var-cp.exp: break in anonymous_structs_and_unions +PASS: gdb.mi/mi-var-cp.exp: continue to anonymous_structs breakpoint +PASS: gdb.mi/mi-var-cp.exp: VT: create root varobj for a +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1 +PASS: gdb.mi/mi-var-cp.exp: path expression for a1 +PASS: gdb.mi/mi-var-cp.exp: expression for a1 +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +Running ./gdb.mi/mi-var-create-rtti.exp ... +PASS: gdb.mi/mi-var-create-rtti.exp: breakpoint at main +PASS: gdb.mi/mi-var-create-rtti.exp: mi runto main +PASS: gdb.mi/mi-var-create-rtti.exp: -var-create sp1 * $sp +Running ./gdb.mi/mi-var-display.exp ... +PASS: gdb.mi/mi-var-display.exp: break-insert operation +PASS: gdb.mi/mi-var-display.exp: run to main +PASS: gdb.mi/mi-var-display.exp: create local variable bar +PASS: gdb.mi/mi-var-display.exp: info type variable bar +PASS: gdb.mi/mi-var-display.exp: show format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new format +PASS: gdb.mi/mi-var-display.exp: assing to variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new value +PASS: gdb.mi/mi-var-display.exp: delete var bar +PASS: gdb.mi/mi-var-display.exp: create local variable foo +PASS: gdb.mi/mi-var-display.exp: info type variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: assing to variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo in hex +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in hex +PASS: gdb.mi/mi-var-display.exp: eval variable foo in octal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in octal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in decimal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in decimal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in natural +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in natural +PASS: gdb.mi/mi-var-display.exp: eval variable foo in binary +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in binary +PASS: gdb.mi/mi-var-display.exp: delete var foo +PASS: gdb.mi/mi-var-display.exp: create local variable weird +PASS: gdb.mi/mi-var-display.exp: get children local variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.integer +PASS: gdb.mi/mi-var-display.exp: set format variable weird.character +PASS: gdb.mi/mi-var-display.exp: set format variable weird.char_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_int +PASS: gdb.mi/mi-var-display.exp: set format variable weird.int_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_array +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_struct +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.u1 +PASS: gdb.mi/mi-var-display.exp: set format variable weird.s2 +PASS: gdb.mi/mi-var-display.exp: delete var weird +PASS: gdb.mi/mi-var-display.exp: break-insert operation 2 +PASS: gdb.mi/mi-var-display.exp: continue to do_special_tests +PASS: gdb.mi/mi-var-display.exp: create local variable u +PASS: gdb.mi/mi-var-display.exp: eval variable u +PASS: gdb.mi/mi-var-display.exp: info type variable u +PASS: gdb.mi/mi-var-display.exp: is u editable +PASS: gdb.mi/mi-var-display.exp: get number of children of u +PASS: gdb.mi/mi-var-display.exp: get children of u +PASS: gdb.mi/mi-var-display.exp: create local variable anonu +PASS: gdb.mi/mi-var-display.exp: eval variable anonu +PASS: gdb.mi/mi-var-display.exp: info type variable anonu +PASS: gdb.mi/mi-var-display.exp: is anonu editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anonu +PASS: gdb.mi/mi-var-display.exp: get children of anonu +PASS: gdb.mi/mi-var-display.exp: create local variable s +PASS: gdb.mi/mi-var-display.exp: eval variable s +PASS: gdb.mi/mi-var-display.exp: info type variable s +PASS: gdb.mi/mi-var-display.exp: is s editable +PASS: gdb.mi/mi-var-display.exp: get number of children of s +PASS: gdb.mi/mi-var-display.exp: get children of s +PASS: gdb.mi/mi-var-display.exp: create local variable anons +PASS: gdb.mi/mi-var-display.exp: eval variable anons +PASS: gdb.mi/mi-var-display.exp: info type variable anons +PASS: gdb.mi/mi-var-display.exp: is anons editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anons +PASS: gdb.mi/mi-var-display.exp: get children of anons +PASS: gdb.mi/mi-var-display.exp: create local variable e +PASS: gdb.mi/mi-var-display.exp: eval variable e +PASS: gdb.mi/mi-var-display.exp: info type variable e +PASS: gdb.mi/mi-var-display.exp: is e editable +PASS: gdb.mi/mi-var-display.exp: get number of children of e +PASS: gdb.mi/mi-var-display.exp: get children of e +PASS: gdb.mi/mi-var-display.exp: create local variable anone +PASS: gdb.mi/mi-var-display.exp: eval variable anone +PASS: gdb.mi/mi-var-display.exp: create duplicate local variable anone +PASS: gdb.mi/mi-var-display.exp: info type variable anone +PASS: gdb.mi/mi-var-display.exp: is anone editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anone +PASS: gdb.mi/mi-var-display.exp: get children of anone +PASS: gdb.mi/mi-var-display.exp: print FP register +PASS: gdb.mi/mi-var-display.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-display.exp: mi runto incr_a +PASS: gdb.mi/mi-var-display.exp: create local variable a1 +PASS: gdb.mi/mi-var-display.exp: create variable a2 in different scope +Running ./gdb.mi/mi-var-invalidate.exp ... +PASS: gdb.mi/mi-var-invalidate.exp: create global variable +PASS: gdb.mi/mi-var-invalidate.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: create local variable linteger +PASS: gdb.mi/mi-var-invalidate.exp: create floating variable +FAIL: gdb.mi/mi-var-invalidate.exp: breakpoint at main +FAIL: gdb.mi/mi-var-invalidate.exp: mi runto main (unknown output after running) +PASS: gdb.mi/mi-var-invalidate.exp: set format variable float_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (1) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple still alive +PASS: gdb.mi/mi-var-invalidate.exp: type simpleton for valid variable global_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not valid anymore due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (2) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable global_simple +Running ./gdb.mi/mi-var-rtti.exp ... +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:37 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:64 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:94 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:149 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:202 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.First (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:245 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: create varobj for ptr in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:269 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:281 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:299 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:323 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:335 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in skip_type_update_when_not_use_rtti +Running ./gdb.mi/mi-watch.exp ... +PASS: gdb.mi/mi-watch.exp: hw watchpoints toggle (1) +PASS: gdb.mi/mi-watch.exp: sw: breakpoint at callee4 +PASS: gdb.mi/mi-watch.exp: sw: mi runto callee4 +PASS: gdb.mi/mi-watch.exp: sw: break-watch operation +PASS: gdb.mi/mi-watch.exp: sw: list of watchpoints +PASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +XPASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +Running ./gdb.mi/mi-watch-nonstop.exp ... +Running ./gdb.mi/pr11022.exp ... +Running ./gdb.modula2/unbounded-array.exp ... +PASS: gdb.modula2/unbounded-array.exp: switch to modula-2 +PASS: gdb.modula2/unbounded-array.exp: print the last legal element of array a +PASS: gdb.modula2/unbounded-array.exp: print unbounded array contents +PASS: gdb.modula2/unbounded-array.exp: print the 1st element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 2nd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 3rd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 4th element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 5th element of array a +Running ./gdb.multi/base.exp ... +PASS: gdb.multi/base.exp: add empty inferior 2 +PASS: gdb.multi/base.exp: switch to inferior 2 +PASS: gdb.multi/base.exp: load hangout file in inferior 2 +PASS: gdb.multi/base.exp: add inferior 3 with -exec goodbye +PASS: gdb.multi/base.exp: info inferiors +PASS: gdb.multi/base.exp: info inferior 2 3 +PASS: gdb.multi/base.exp: info inferior 1-2 +PASS: gdb.multi/base.exp: switch to inferior 1 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 1 +PASS: gdb.multi/base.exp: switch to inferior 3 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 3 +PASS: gdb.multi/base.exp: switch back to inferior 1 +PASS: gdb.multi/base.exp: set listsize 1 +PASS: gdb.multi/base.exp: list commonfun in hello +PASS: gdb.multi/base.exp: print hglob +PASS: gdb.multi/base.exp: print glob (hello) +PASS: gdb.multi/base.exp: switch to inferior 3 to print globals +PASS: gdb.multi/base.exp: print gglob +PASS: gdb.multi/base.exp: print glob (goodbye) +PASS: gdb.multi/base.exp: list commonfun in goodbye +PASS: gdb.multi/base.exp: switch to inferior 1 to run it +PASS: gdb.multi/base.exp: break hello +PASS: gdb.multi/base.exp: continue +PASS: gdb.multi/base.exp: remove-inferiors 2-3 +PASS: gdb.multi/base.exp: check remove-inferiors +Running ./gdb.multi/bkpt-multi-exec.exp ... +Running ./gdb.multi/multi-arch-exec.exp ... +Running ./gdb.multi/multi-arch.exp ... +Running ./gdb.multi/watchpoint-multi.exp ... +UNTESTED: gdb.multi/watchpoint-multi.exp: watchpoint-multi.exp +Running ./gdb.objc/basicclass.exp ... +UNSUPPORTED: gdb.objc/basicclass.exp: Couldn't compile ./gdb.objc/basicclass.m: unrecognized error +Running ./gdb.objc/nondebug.exp ... +UNSUPPORTED: gdb.objc/nondebug.exp: Couldn't compile ./gdb.objc/nondebug.m: unrecognized error +Running ./gdb.objc/objcdecode.exp ... +UNSUPPORTED: gdb.objc/objcdecode.exp: Couldn't compile ./gdb.objc/objcdecode.m: unrecognized error +Running ./gdb.objc/print.exp ... +PASS: gdb.objc/print.exp: set language objective-c +PASS: gdb.objc/print.exp: set language to "objective-c" +PASS: gdb.objc/print.exp: check fp + text +PASS: gdb.objc/print.exp: p 1. +PASS: gdb.objc/print.exp: p 1.5 +PASS: gdb.objc/print.exp: p 1.f +PASS: gdb.objc/print.exp: p 1.5f +PASS: gdb.objc/print.exp: p 1.l +PASS: gdb.objc/print.exp: p 1.5l +PASS: gdb.objc/print.exp: p 0x1.1 +PASS: gdb.objc/print.exp: reject p 1.1x +PASS: gdb.objc/print.exp: reject p 1.1ff +PASS: gdb.objc/print.exp: reject p 1.1ll +Running ./gdb.opencl/callfuncs.exp ... +Running ./gdb.opencl/convs_casts.exp ... +Running ./gdb.opencl/datatypes.exp ... +Running ./gdb.opencl/operators.exp ... +Running ./gdb.opencl/vec_comps.exp ... +Running ./gdb.opt/clobbered-registers-O2.exp ... +PASS: gdb.opt/clobbered-registers-O2.exp: Backtracing +PASS: gdb.opt/clobbered-registers-O2.exp: print operand0 +PASS: gdb.opt/clobbered-registers-O2.exp: print operand1 +Running ./gdb.opt/inline-break.exp ... +PASS: gdb.opt/inline-break.exp: break func1 +PASS: gdb.opt/inline-break.exp: break func2 +PASS: gdb.opt/inline-break.exp: break func3b +FAIL: gdb.opt/inline-break.exp: break func4b +PASS: gdb.opt/inline-break.exp: break func5b +FAIL: gdb.opt/inline-break.exp: break func6b +PASS: gdb.opt/inline-break.exp: break func7b +PASS: gdb.opt/inline-break.exp: break func8b +PASS: gdb.opt/inline-break.exp: print func1 +PASS: gdb.opt/inline-break.exp: print func2 +Running ./gdb.opt/inline-bt.exp ... +PASS: gdb.opt/inline-bt.exp: continue to bar (1) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (1) +PASS: gdb.opt/inline-bt.exp: bar not inlined +PASS: gdb.opt/inline-bt.exp: continue to bar (2) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (2) +PASS: gdb.opt/inline-bt.exp: up from bar (2) +PASS: gdb.opt/inline-bt.exp: func1 inlined (2) +PASS: gdb.opt/inline-bt.exp: continue to bar (3) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (3) +PASS: gdb.opt/inline-bt.exp: up from bar (3) +PASS: gdb.opt/inline-bt.exp: func1 inlined (3) +PASS: gdb.opt/inline-bt.exp: up from func1 (3) +PASS: gdb.opt/inline-bt.exp: func2 inlined (3) +Running ./gdb.opt/inline-cmds.exp ... +PASS: gdb.opt/inline-cmds.exp: set listsize 1 +PASS: gdb.opt/inline-cmds.exp: continue to bar (1) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (1) +PASS: gdb.opt/inline-cmds.exp: up from bar (1) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (1) +PASS: gdb.opt/inline-cmds.exp: continue to bar (2) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (2) +PASS: gdb.opt/inline-cmds.exp: up from bar (2) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (2) +PASS: gdb.opt/inline-cmds.exp: up from func1 (2) +PASS: gdb.opt/inline-cmds.exp: func2 inlined (2) +PASS: gdb.opt/inline-cmds.exp: continue to marker +PASS: gdb.opt/inline-cmds.exp: backtrace from marker +PASS: gdb.opt/inline-cmds.exp: marker not inlined +PASS: gdb.opt/inline-cmds.exp: next over inlined functions +PASS: gdb.opt/inline-cmds.exp: next past inlined func1 +PASS: gdb.opt/inline-cmds.exp: print x before func1 +PASS: gdb.opt/inline-cmds.exp: backtrace does not include func1 +PASS: gdb.opt/inline-cmds.exp: stepped over call to func1 +FAIL: gdb.opt/inline-cmds.exp: step into func1 +PASS: gdb.opt/inline-cmds.exp: finish from func1 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: consecutive func1 +PASS: gdb.opt/inline-cmds.exp: next to first func1 +KFAIL: gdb.opt/inline-cmds.exp: next to second func1 (PRMS: gdb/NNNN) +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: func1 then func3 +PASS: gdb.opt/inline-cmds.exp: next to func1 before func3 +PASS: gdb.opt/inline-cmds.exp: next to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: finish into func1 +PASS: gdb.opt/inline-cmds.exp: next to finish marker +FAIL: gdb.opt/inline-cmds.exp: step into finish marker +PASS: gdb.opt/inline-cmds.exp: finish from marker to func1 +PASS: gdb.opt/inline-cmds.exp: step into func1 for finish +PASS: gdb.opt/inline-cmds.exp: finish from func1 to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: before the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach 1 the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at main of outer_inline +PASS: gdb.opt/inline-cmds.exp: enter outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline2 +PASS: gdb.opt/inline-cmds.exp: enter outer_inline1 from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline1 +PASS: gdb.opt/inline-cmds.exp: enter noinline from outer_inline1 +PASS: gdb.opt/inline-cmds.exp: backtrace at noinline from outer_inline1 +FAIL: gdb.opt/inline-cmds.exp: enter inlined_fn from noinline +FAIL: gdb.opt/inline-cmds.exp: backtrace at inlined_fn from noinline +FAIL: gdb.opt/inline-cmds.exp: inlined_fn from noinline inlined +FAIL: gdb.opt/inline-cmds.exp: up to noinline +FAIL: gdb.opt/inline-cmds.exp: noinline from outer_inline1 not inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline1 +PASS: gdb.opt/inline-cmds.exp: outer_inline1 inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline2 +FAIL: gdb.opt/inline-cmds.exp: outer_inline2 inlined +FAIL: gdb.opt/inline-cmds.exp: up from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: main not inlined +Running ./gdb.opt/inline-locals.exp ... +PASS: gdb.opt/inline-locals.exp: continue to bar (1) +PASS: gdb.opt/inline-locals.exp: continue to bar (2) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (2) +PASS: gdb.opt/inline-locals.exp: up from bar (2) +PASS: gdb.opt/inline-locals.exp: func1 inlined (2) +PASS: gdb.opt/inline-locals.exp: info locals above bar (2) +PASS: gdb.opt/inline-locals.exp: info args above bar (2) +PASS: gdb.opt/inline-locals.exp: print local (2) +PASS: gdb.opt/inline-locals.exp: print out of scope local +PASS: gdb.opt/inline-locals.exp: continue to bar (3) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (3) +PASS: gdb.opt/inline-locals.exp: up from bar (3) +PASS: gdb.opt/inline-locals.exp: func1 inlined (3) +PASS: gdb.opt/inline-locals.exp: info locals above bar (3) +PASS: gdb.opt/inline-locals.exp: info args above bar (3) +PASS: gdb.opt/inline-locals.exp: print local (3) +Running ./gdb.pascal/floats.exp ... +UNSUPPORTED: gdb.pascal/floats.exp: No pascal compiler found +UNTESTED: gdb.pascal/floats.exp: floats.exp +Running ./gdb.pascal/gdb11492.exp ... +UNSUPPORTED: gdb.pascal/gdb11492.exp: No pascal compiler found +UNTESTED: gdb.pascal/gdb11492.exp: gdb11492.exp +Running ./gdb.pascal/hello.exp ... +UNSUPPORTED: gdb.pascal/hello.exp: No pascal compiler found +Running ./gdb.pascal/integers.exp ... +UNSUPPORTED: gdb.pascal/integers.exp: No pascal compiler found +Running ./gdb.pascal/print.exp ... +PASS: gdb.pascal/print.exp: set language pascal +PASS: gdb.pascal/print.exp: set language to "pascal" +PASS: gdb.pascal/print.exp: check fp + text +PASS: gdb.pascal/print.exp: p 1. +PASS: gdb.pascal/print.exp: p 1.5 +PASS: gdb.pascal/print.exp: p 1.f +PASS: gdb.pascal/print.exp: p 1.5f +PASS: gdb.pascal/print.exp: p 1.l +PASS: gdb.pascal/print.exp: p 1.5l +PASS: gdb.pascal/print.exp: p 0x1.1 +PASS: gdb.pascal/print.exp: reject p 1.1x +PASS: gdb.pascal/print.exp: reject p 1.1ff +PASS: gdb.pascal/print.exp: reject p 1.1ll +Running ./gdb.pascal/types.exp ... +PASS: gdb.pascal/types.exp: set language pascal +PASS: gdb.pascal/types.exp: set language to "pascal" +PASS: gdb.pascal/types.exp: pt 123 +PASS: gdb.pascal/types.exp: pt TRUE +PASS: gdb.pascal/types.exp: pt FALSE +PASS: gdb.pascal/types.exp: pt 'a' +KFAIL: gdb.pascal/types.exp: pt 'a simple string' (PRMS: gdb/2326) +PASS: gdb.pascal/types.exp: pt .44 +PASS: gdb.pascal/types.exp: pt 44.0 +PASS: gdb.pascal/types.exp: pt 10e20 +PASS: gdb.pascal/types.exp: pt 10E20 +Running ./gdb.python/lib-types.exp ... +PASS: gdb.python/lib-types.exp: python import gdb.types +PASS: gdb.python/lib-types.exp: python const_class1_obj = gdb.parse_and_eval ('const_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_class1_obj = gdb.types.get_basic_type (const_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_class1_obj.type)) +PASS: gdb.python/lib-types.exp: const stripping +PASS: gdb.python/lib-types.exp: python volatile_class1_obj = gdb.parse_and_eval ('volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_volatile_class1_obj = gdb.types.get_basic_type (volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile stripping +PASS: gdb.python/lib-types.exp: python const_volatile_class1_obj = gdb.parse_and_eval ('const_volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_volatile_class1_obj = gdb.types.get_basic_type (const_volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile+const stripping +PASS: gdb.python/lib-types.exp: python typedef_class1_obj = gdb.parse_and_eval ('typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_class1_obj = gdb.types.get_basic_type (typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: typedef stripping +PASS: gdb.python/lib-types.exp: python class1_ref_obj = gdb.parse_and_eval ('class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_class1_ref_obj = gdb.types.get_basic_type (class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: reference stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_ref_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_ref_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_const_typedef_class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef/ref stripping +PASS: gdb.python/lib-types.exp: python class1_obj = gdb.parse_and_eval ('class1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'nope')) +PASS: gdb.python/lib-types.exp: python subclass1_obj = gdb.parse_and_eval ('subclass1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (subclass1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python enum1_obj = gdb.parse_and_eval ('enum1_obj') +PASS: gdb.python/lib-types.exp: python enum1_dict = gdb.types.make_enum_dict (enum1_obj.type) +PASS: gdb.python/lib-types.exp: python enum1_list = sorted (enum1_dict.items ()) +PASS: gdb.python/lib-types.exp: python print (enum1_list) +PASS: gdb.python/lib-types.exp: python struct_a = gdb.lookup_type ('struct A') +PASS: gdb.python/lib-types.exp: python print (struct_a.keys ()) +PASS: gdb.python/lib-types.exp: python print ([k for k,v in gdb.types.deep_items(struct_a)]) +Running ./gdb.python/py-arch.exp ... +PASS: gdb.python/py-arch.exp: test number of instructions 1 +PASS: gdb.python/py-arch.exp: test number of instructions 2 +PASS: gdb.python/py-arch.exp: test number of instructions 3 +PASS: gdb.python/py-arch.exp: test number of instructions 4 +PASS: gdb.python/py-arch.exp: test key addr +PASS: gdb.python/py-arch.exp: test key asm +PASS: gdb.python/py-arch.exp: test key length +PASS: gdb.python/py-arch.exp: test exception +Running ./gdb.python/py-block.exp ... +PASS: gdb.python/py-block.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-block.exp: Check block not None +PASS: gdb.python/py-block.exp: First anonymous block +PASS: gdb.python/py-block.exp: Check start not None +PASS: gdb.python/py-block.exp: Check end not None +PASS: gdb.python/py-block.exp: Not a global block +PASS: gdb.python/py-block.exp: Not a static block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Is the global block +PASS: gdb.python/py-block.exp: Is the static block +PASS: gdb.python/py-block.exp: Get superblock +PASS: gdb.python/py-block.exp: Second anonymous block +PASS: gdb.python/py-block.exp: Get superblock 2 +PASS: gdb.python/py-block.exp: Print superblock 2 function +PASS: gdb.python/py-block.exp: up +PASS: gdb.python/py-block.exp: Check Frame 2's block not None +PASS: gdb.python/py-block.exp: main block +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +Running ./gdb.python/py-breakpoint.exp ... +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check for two breakpoints +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: Check expected variable result after 6 iterations +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint enabled. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint thread +PASS: gdb.python/py-breakpoint.exp: Check breakpoint type +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints before delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint invalidated +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints after delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional has been set +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional breakpoint stopped after five iterations +PASS: gdb.python/py-breakpoint.exp: Test conditional read +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test breakpoint stopped after six iterations +PASS: gdb.python/py-breakpoint.exp: commands $bpnum +PASS: gdb.python/py-breakpoint.exp: print "Command for breakpoint has been executed." +PASS: gdb.python/py-breakpoint.exp: print result +PASS: gdb.python/py-breakpoint.exp: end +PASS: gdb.python/py-breakpoint.exp: python print (blist[len(blist)-1].commands) +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints shows visible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - class bp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - inf_i = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.inf_i = gdb.parse_and_eval("i") +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - if self.inf_i == 3: +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - class bp_also_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - if self.count == 9: +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - class basic (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - end +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check inferior value matches python accounting +PASS: gdb.python/py-breakpoint.exp: Check python accounting matches inferior +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check you cannot add a CLI condition to a Python breakpoint that +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - python +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - def stop_func (): +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - return True +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - end +PASS: gdb.python/py-breakpoint.exp: Assign stop function to a breakpoint that has a condition +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function has not been yet executed (ie count = 0) +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function is run when location also has normal bp +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - class wp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - self.result = gdb.parse_and_eval("result") +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - if self.result == 788: +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - end +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check that this unrelated breakpoints eval function was never called. +Running ./gdb.python/py-cmd.exp ... +PASS: gdb.python/py-cmd.exp: input simple command - python +PASS: gdb.python/py-cmd.exp: input simple command - class test_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple command - super (test_cmd, self).__init__ ("test_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input simple command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple command - test_cmd () +PASS: gdb.python/py-cmd.exp: input simple command - end +PASS: gdb.python/py-cmd.exp: call simple command +PASS: gdb.python/py-cmd.exp: input prefix command - python +PASS: gdb.python/py-cmd.exp: input prefix command - class prefix_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command - super (prefix_cmd, self).__init__ ("prefix_cmd", gdb.COMMAND_OBSCURE, gdb.COMPLETE_NONE, True) +PASS: gdb.python/py-cmd.exp: input prefix command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command - print ("prefix_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command - prefix_cmd () +PASS: gdb.python/py-cmd.exp: input prefix command - end +PASS: gdb.python/py-cmd.exp: call prefix command +PASS: gdb.python/py-cmd.exp: input subcommand - python +PASS: gdb.python/py-cmd.exp: input subcommand - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand - super (subcmd, self).__init__ ("prefix_cmd subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand - end +PASS: gdb.python/py-cmd.exp: call subcmd +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - python +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - class prefix_cmd2 (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - super (prefix_cmd2, self).__init__ ("prefix_cmd2", gdb.COMMAND_OBSCURE, prefix = True, completer_class = gdb.COMPLETE_FILENAME) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - print ("prefix_cmd2 output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - prefix_cmd2 () +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - end +PASS: gdb.python/py-cmd.exp: call prefix command, keyword arguments +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - python +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - super (subcmd, self).__init__ ("prefix_cmd2 subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - end +PASS: gdb.python/py-cmd.exp: call subcmd under prefix_cmd2 +PASS: gdb.python/py-cmd.exp: input new subcommand - python +PASS: gdb.python/py-cmd.exp: input new subcommand - class newsubcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input new subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input new subcommand - super (newsubcmd, self).__init__ ("info newsubcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input new subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input new subcommand - print ("newsubcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input new subcommand - newsubcmd () +PASS: gdb.python/py-cmd.exp: input new subcommand - end +PASS: gdb.python/py-cmd.exp: call newsubcmd +PASS: gdb.python/py-cmd.exp: input command to throw error - python +PASS: gdb.python/py-cmd.exp: input command to throw error - class test_error_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input command to throw error - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input command to throw error - super (test_error_cmd, self).__init__ ("test_error_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input command to throw error - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input command to throw error - raise gdb.GdbError ('you lose!') +PASS: gdb.python/py-cmd.exp: input command to throw error - test_error_cmd () +PASS: gdb.python/py-cmd.exp: input command to throw error - end +PASS: gdb.python/py-cmd.exp: call error command +PASS: gdb.python/py-cmd.exp: string_to_argv ("1 2 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ("'1 2' 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ('"1 2" 3') +PASS: gdb.python/py-cmd.exp: string_to_argv ('1\ 2 3') +PASS: gdb.python/py-cmd.exp: input simple user-defined command - python +PASS: gdb.python/py-cmd.exp: input simple user-defined command - class test_help (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - """Docstring""" +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - super (test_help, self).__init__ ("test_help", gdb.COMMAND_USER) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - test_help () +PASS: gdb.python/py-cmd.exp: input simple user-defined command - end +PASS: gdb.python/py-cmd.exp: call simple user-defined command +PASS: gdb.python/py-cmd.exp: see user-defined command in `help user-defined` +Running ./gdb.python/py-error.exp ... +PASS: gdb.python/py-error.exp: set host-charset IBM1047 +PASS: gdb.python/py-error.exp: main reached +PASS: gdb.python/py-error.exp: no delayed error +Running ./gdb.python/py-events.exp ... +Running ./gdb.python/py-evsignal.exp ... +KFAIL: gdb.python/py-evsignal.exp: Signal Thread 3 (PRMS: python/12966) +Running ./gdb.python/py-evthreads.exp ... +KFAIL: gdb.python/py-evthreads.exp: Run to breakpoint 1 (PRMS: python/12966) +Running ./gdb.python/py-explore-cc.exp ... +PASS: gdb.python/py-explore-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore-cc.exp: explore A +PASS: gdb.python/py-explore-cc.exp: explore a +PASS: gdb.python/py-explore-cc.exp: explore int_ref +PASS: gdb.python/py-explore-cc.exp: explore int_ptr_ref +PASS: gdb.python/py-explore-cc.exp: explore_int_ptr_ref_as_single_value_pointer +PASS: gdb.python/py-explore-cc.exp: explore b +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_A +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_b +PASS: gdb.python/py-explore-cc.exp: explore B +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_B +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_c +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_B +Running ./gdb.python/py-explore.exp ... +PASS: gdb.python/py-explore.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore.exp: explore i +PASS: gdb.python/py-explore.exp: explore ss +PASS: gdb.python/py-explore.exp: explore *ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_t +PASS: gdb.python/py-explore.exp: explore ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_ptr as single value pointer +PASS: gdb.python/py-explore.exp: explore darray_ref +PASS: gdb.python/py-explore.exp: no_to_explore_as_pointer +PASS: gdb.python/py-explore.exp: explore_as_array +PASS: gdb.python/py-explore.exp: explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array +PASS: gdb.python/py-explore.exp: explore su +PASS: gdb.python/py-explore.exp: explore su.d +PASS: gdb.python/py-explore.exp: end su.d exploration +PASS: gdb.python/py-explore.exp: end su exploration +PASS: gdb.python/py-explore.exp: explore cs +PASS: gdb.python/py-explore.exp: explore cs.s +PASS: gdb.python/py-explore.exp: end cs.s exploration +PASS: gdb.python/py-explore.exp: explore cs.u +PASS: gdb.python/py-explore.exp: end cs.u exploration +PASS: gdb.python/py-explore.exp: end cs exploration +PASS: gdb.python/py-explore.exp: explore cu +PASS: gdb.python/py-explore.exp: explore cu.sa +PASS: gdb.python/py-explore.exp: explore cu.sa[0] +PASS: gdb.python/py-explore.exp: end cu.sa[0] exploration +PASS: gdb.python/py-explore.exp: end cu.sa exploration +PASS: gdb.python/py-explore.exp: end cu exploration +PASS: gdb.python/py-explore.exp: explore int +PASS: gdb.python/py-explore.exp: explore struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 0 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 1 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore union SimpleUnion +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 0 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 1 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 1 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 2 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 2 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 3 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 3 +PASS: gdb.python/py-explore.exp: return to GDB prompt from union SimpleUnion +PASS: gdb.python/py-explore.exp: explore SS +PASS: gdb.python/py-explore.exp: explore type SS feild 0 +PASS: gdb.python/py-explore.exp: return to SS from field 0 +PASS: gdb.python/py-explore.exp: explore type SS feild 1 +PASS: gdb.python/py-explore.exp: return to SS field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from SS +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 0 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 1 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 1 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 2 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 2 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexStruct type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +Running ./gdb.python/py-finish-breakpoint2.exp ... +PASS: gdb.python/py-finish-breakpoint2.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint2.exp: run to exception 1 +PASS: gdb.python/py-finish-breakpoint2.exp: check BP count +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: check FinishBreakpoint in catch() +PASS: gdb.python/py-finish-breakpoint2.exp: check finish BP removal +PASS: gdb.python/py-finish-breakpoint2.exp: continue to second exception +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: FinishBreakpoint with exception thrown not caught +Running ./gdb.python/py-finish-breakpoint.exp ... +PASS: gdb.python/py-finish-breakpoint.exp: disable confirmation +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: continue to the function to finish +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint with default frame value +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check return_value at init +PASS: gdb.python/py-finish-breakpoint.exp: check MyFinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return_value +PASS: gdb.python/py-finish-breakpoint.exp: check finishBP on default frame has been hit +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer normal hit +PASS: gdb.python/py-finish-breakpoint.exp: return to main() +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP not allowed in main +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +FAIL: gdb.python/py-finish-breakpoint.exp: ensure that shared lib has no debug info +FAIL: gdb.python/py-finish-breakpoint.exp: setting breakpoint at do_nothing +FAIL: gdb.python/py-finish-breakpoint.exp: continue to do_nothing +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +FAIL: gdb.python/py-finish-breakpoint.exp: check FinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return value without debug symbol +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: set BP after the jump +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set a conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP in a breakpoint condition +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set BP in condition +PASS: gdb.python/py-finish-breakpoint.exp: stop in condition function +PASS: gdb.python/py-finish-breakpoint.exp: finish condition evaluation +PASS: gdb.python/py-finish-breakpoint.exp: stop at conditional breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: FinishBP stop at during explicit function call +PASS: gdb.python/py-finish-breakpoint.exp: switch to exit() test +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exit() +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exit +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exec +PASS: gdb.python/py-finish-breakpoint.exp: catch exec +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exec +Running ./gdb.python/py-frame.exp ... +PASS: gdb.python/py-frame.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame.exp: test Frame.architecture() +PASS: gdb.python/py-frame.exp: test i +PASS: gdb.python/py-frame.exp: test f +PASS: gdb.python/py-frame.exp: test b +PASS: gdb.python/py-frame.exp: test i = 1.1 +PASS: gdb.python/py-frame.exp: test double i +PASS: gdb.python/py-frame.exp: test f = 2.2 +PASS: gdb.python/py-frame.exp: test double f +PASS: gdb.python/py-frame.exp: test i = 99 +PASS: gdb.python/py-frame.exp: test int i +PASS: gdb.python/py-frame.exp: continue to breakpoint: breakpoint at f2 +PASS: gdb.python/py-frame.exp: selected frame -vs- newest frame +PASS: gdb.python/py-frame.exp: newest frame -vs- newest frame +PASS: gdb.python/py-frame.exp: test equality comparison (false) +PASS: gdb.python/py-frame.exp: test equality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (false) +PASS: gdb.python/py-frame.exp: test Frame.is_valid +PASS: gdb.python/py-frame.exp: test Frame.name +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test gdb.frame_stop_reason_string +PASS: gdb.python/py-frame.exp: test Frame.pc +PASS: gdb.python/py-frame.exp: test Frame.older +PASS: gdb.python/py-frame.exp: test Frame.newer +PASS: gdb.python/py-frame.exp: test Frame.read_var - error +PASS: gdb.python/py-frame.exp: test Frame.read_var - success +PASS: gdb.python/py-frame.exp: test gdb.selected_frame +Running ./gdb.python/py-frame-inline.exp ... +PASS: gdb.python/py-frame-inline.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame-inline.exp: info frame +PASS: gdb.python/py-frame-inline.exp: up +PASS: gdb.python/py-frame-inline.exp: python print (gdb.selected_frame().read_var('l')) +Running ./gdb.python/py-function.exp ... +PASS: gdb.python/py-function.exp: input convenience function - python +PASS: gdb.python/py-function.exp: input convenience function - class test_func (gdb.Function): +PASS: gdb.python/py-function.exp: input convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input convenience function - super (test_func, self).__init__ ("test_func") +PASS: gdb.python/py-function.exp: input convenience function - def invoke (self, arg): +PASS: gdb.python/py-function.exp: input convenience function - return "test_func output, arg = %s" % arg.string () +PASS: gdb.python/py-function.exp: input convenience function - test_func () +PASS: gdb.python/py-function.exp: input convenience function - end +PASS: gdb.python/py-function.exp: call function +PASS: gdb.python/py-function.exp: input value-returning convenience function - python +PASS: gdb.python/py-function.exp: input value-returning convenience function - class Double (gdb.Function): +PASS: gdb.python/py-function.exp: input value-returning convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input value-returning convenience function - super (Double, self).__init__ ("double") +PASS: gdb.python/py-function.exp: input value-returning convenience function - def invoke (self, n): +PASS: gdb.python/py-function.exp: input value-returning convenience function - return n*2 +PASS: gdb.python/py-function.exp: input value-returning convenience function - Double () +PASS: gdb.python/py-function.exp: input value-returning convenience function - end +PASS: gdb.python/py-function.exp: call value-returning function +PASS: gdb.python/py-function.exp: input int-returning function - python +PASS: gdb.python/py-function.exp: input int-returning function - class Yes(gdb.Function): +PASS: gdb.python/py-function.exp: input int-returning function - def __init__(self): +PASS: gdb.python/py-function.exp: input int-returning function - gdb.Function.__init__(self, 'yes') +PASS: gdb.python/py-function.exp: input int-returning function - def invoke(self): +PASS: gdb.python/py-function.exp: input int-returning function - return 1 +PASS: gdb.python/py-function.exp: input int-returning function - Yes () +PASS: gdb.python/py-function.exp: input int-returning function - end +PASS: gdb.python/py-function.exp: call yes with && +PASS: gdb.python/py-function.exp: call yes with || +PASS: gdb.python/py-function.exp: Test GDBError - python +PASS: gdb.python/py-function.exp: Test GDBError - class GDBError(gdb.Function): +PASS: gdb.python/py-function.exp: Test GDBError - def __init__(self): +PASS: gdb.python/py-function.exp: Test GDBError - gdb.Function.__init__(self, 'gdberror') +PASS: gdb.python/py-function.exp: Test GDBError - def invoke(self): +PASS: gdb.python/py-function.exp: Test GDBError - raise gdb.GdbError("This is a GdbError") +PASS: gdb.python/py-function.exp: Test GDBError - GDBError () +PASS: gdb.python/py-function.exp: Test GDBError - end +PASS: gdb.python/py-function.exp: Test GdbError. There should not be a stack trace +PASS: gdb.python/py-function.exp: Test Normal Error - python +PASS: gdb.python/py-function.exp: Test Normal Error - class NormalError(gdb.Function): +PASS: gdb.python/py-function.exp: Test Normal Error - def __init__(self): +PASS: gdb.python/py-function.exp: Test Normal Error - gdb.Function.__init__(self, 'normalerror') +PASS: gdb.python/py-function.exp: Test Normal Error - def invoke(self): +PASS: gdb.python/py-function.exp: Test Normal Error - raise RuntimeError("This is a Normal Error") +PASS: gdb.python/py-function.exp: Test Normal Error - NormalError () +PASS: gdb.python/py-function.exp: Test Normal Error - end +PASS: gdb.python/py-function.exp: set python print-stack full +PASS: gdb.python/py-function.exp: Test a Runtime error. There should be a stack trace. +PASS: gdb.python/py-function.exp: input command-calling function - python +PASS: gdb.python/py-function.exp: input command-calling function - class CallCommand(gdb.Function): +PASS: gdb.python/py-function.exp: input command-calling function - def __init__(self): +PASS: gdb.python/py-function.exp: input command-calling function - gdb.Function.__init__(self, 'call_command') +PASS: gdb.python/py-function.exp: input command-calling function - def invoke(self): +PASS: gdb.python/py-function.exp: input command-calling function - return gdb.execute('print 1', to_string=True) +PASS: gdb.python/py-function.exp: input command-calling function - CallCommand () +PASS: gdb.python/py-function.exp: input command-calling function - end +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command. +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command, again. +Running ./gdb.python/py-inferior.exp ... +PASS: gdb.python/py-inferior.exp: successfully compiled posix threads test case +PASS: gdb.python/py-inferior.exp: get inferiors list +PASS: gdb.python/py-inferior.exp: verify inferiors list +PASS: gdb.python/py-inferior.exp: test equality comparison (true) +PASS: gdb.python/py-inferior.exp: test Inferior.num +PASS: gdb.python/py-inferior.exp: test Inferior.pid +PASS: gdb.python/py-inferior.exp: test Inferior.was_attached +PASS: gdb.python/py-inferior.exp: test Inferior.threads +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to check_threads +PASS: gdb.python/py-inferior.exp: test Inferior.threads 2 +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to Break here. +PASS: gdb.python/py-inferior.exp: read str contents +PASS: gdb.python/py-inferior.exp: write str +PASS: gdb.python/py-inferior.exp: ensure str was changed in the inferior +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: find string pattern +PASS: gdb.python/py-inferior.exp: pattern not found at end of range +PASS: gdb.python/py-inferior.exp: pattern found at end of range +PASS: gdb.python/py-inferior.exp: py from struct import * +PASS: gdb.python/py-inferior.exp: set int16_search_buf[10] = 0x1234 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int16_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<H',0x1234) +PASS: gdb.python/py-inferior.exp: find 16-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set int32_search_buf[10] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int32_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I',0x12345678) +PASS: gdb.python/py-inferior.exp: find 32-bit pattern, with python pattern +PASS: gdb.python/py-inferior.exp: set int64_search_buf[10] = 0xfedcba9876543210LL +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int64_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<Q', 0xfedcba9876543210) +PASS: gdb.python/py-inferior.exp: find 64-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set *(int8_t*) &search_buf[10] = 0x62 +PASS: gdb.python/py-inferior.exp: set *(int16_t*) &search_buf[11] = 0x6363 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[13] = 0x64646464 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf[0].address +PASS: gdb.python/py-inferior.exp: py pattern1 = pack('B', 0x62) +PASS: gdb.python/py-inferior.exp: py pattern2 = pack('<H', 0x6363) +PASS: gdb.python/py-inferior.exp: py pattern3 = pack('<I', 0x64646464) +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[0*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[1*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py start_addr = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py end_addr = start_addr + gdb.selected_frame ().read_var ('search_buf_size') +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I', 0x12345678) +PASS: gdb.python/py-inferior.exp: py first = gdb.inferiors()[0].search_memory (start_addr,end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 1st result +PASS: gdb.python/py-inferior.exp: py start_addr = first + 1 +PASS: gdb.python/py-inferior.exp: py second = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 2nd result +PASS: gdb.python/py-inferior.exp: py start_addr = second + 1 +PASS: gdb.python/py-inferior.exp: py third = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 3rd result +PASS: gdb.python/py-inferior.exp: get initial list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: add empty inferior 2 +PASS: gdb.python/py-inferior.exp: get new list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: remove-inferiors 3 +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: First inferior selected +PASS: gdb.python/py-inferior.exp: Create new inferior +PASS: gdb.python/py-inferior.exp: Switch to third inferior +PASS: gdb.python/py-inferior.exp: Third inferior selected +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: Remove second inferior +Running ./gdb.python/py-infthread.exp ... +PASS: gdb.python/py-infthread.exp: test gdb.selected_thread +PASS: gdb.python/py-infthread.exp: verify InferiorThread object +PASS: gdb.python/py-infthread.exp: test Inferior.num +PASS: gdb.python/py-infthread.exp: test InferiorThread.ptid +PASS: gdb.python/py-infthread.exp: get supplied name of current thread +PASS: gdb.python/py-infthread.exp: set name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread +PASS: gdb.python/py-infthread.exp: reset name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread again +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_stopped +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_running +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_exited +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +PASS: gdb.python/py-infthread.exp: kill inferior 1 +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +Running ./gdb.python/py-mi.exp ... +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 328 (set breakpoint) +PASS: gdb.python/py-mi.exp: create container varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine container children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create nscont varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine nscont children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create string_1 varobj +PASS: gdb.python/py-mi.exp: create estring varobj +PASS: gdb.python/py-mi.exp: assign string_1 from string_2 +PASS: gdb.python/py-mi.exp: update string varobj after assignment +PASS: gdb.python/py-mi.exp: create container varobj +PASS: gdb.python/py-mi.exp: examine container children=0 +PASS: gdb.python/py-mi.exp: next over update 1 +PASS: gdb.python/py-mi.exp: varobj update 1 +PASS: gdb.python/py-mi.exp: next over update 2 +PASS: gdb.python/py-mi.exp: varobj update 2 +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: varobj update after choosing default +PASS: gdb.python/py-mi.exp: choose visualizer using expression +PASS: gdb.python/py-mi.exp: varobj update after choosing via expression +PASS: gdb.python/py-mi.exp: list varobj children after selecting child range +PASS: gdb.python/py-mi.exp: list varobj children after resetting child range +PASS: gdb.python/py-mi.exp: next over update 3 +PASS: gdb.python/py-mi.exp: set update range +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: list selected children after setting range +PASS: gdb.python/py-mi.exp: list children after listing selected range +PASS: gdb.python/py-mi.exp: next over update 4 +PASS: gdb.python/py-mi.exp: update after next with restricted range +PASS: gdb.python/py-mi.exp: set update range with non-zero start +PASS: gdb.python/py-mi.exp: update varobj with change outside selected range +PASS: gdb.python/py-mi.exp: next over update 5 +PASS: gdb.python/py-mi.exp: create second container varobj +PASS: gdb.python/py-mi.exp: update varobj, no children requested +PASS: gdb.python/py-mi.exp: next over update 6 +PASS: gdb.python/py-mi.exp: update varobj 2, no children requested +PASS: gdb.python/py-mi.exp: run to 131 (set breakpoint) +PASS: gdb.python/py-mi.exp: create outer varobj +PASS: gdb.python/py-mi.exp: list children of outer +PASS: gdb.python/py-mi.exp: list children of outer.s +PASS: gdb.python/py-mi.exp: next over outer update +PASS: gdb.python/py-mi.exp: update after updating element of outer +PASS: gdb.python/py-mi.exp: run to 222 (set breakpoint) +PASS: gdb.python/py-mi.exp: update after type change +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create nstype varobj +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: create nstype2 varobj +PASS: gdb.python/py-mi.exp: list children after setting exception flag +PASS: gdb.python/py-mi.exp: create me varobj +PASS: gdb.python/py-mi.exp: evaluate me varobj +PASS: gdb.python/py-mi.exp: printer whose children are returned as a list +PASS: gdb.python/py-mi.exp: run to 254 (set breakpoint) +PASS: gdb.python/py-mi.exp: create varobj for c +PASS: gdb.python/py-mi.exp: choose array visualizer for c +PASS: gdb.python/py-mi.exp: list children of c +PASS: gdb.python/py-mi.exp: next over change of array element +PASS: gdb.python/py-mi.exp: update varobj after element change +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create fake varobj +PASS: gdb.python/py-mi.exp: list children of fake +PASS: gdb.python/py-mi.exp: list children fake.private +PASS: gdb.python/py-mi.exp: Install visualizer on a cplus_fake_child +Running ./gdb.python/py-objfile.exp ... +PASS: gdb.python/py-objfile.exp: Find a symbol in objfile +PASS: gdb.python/py-objfile.exp: Get backing object file +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity after unload +Running ./gdb.python/py-objfile-script.exp ... +PASS: gdb.python/py-objfile-script.exp: set auto-load safe-path +PASS: gdb.python/py-objfile-script.exp: info auto-load python-scripts +PASS: gdb.python/py-objfile-script.exp: b 38 +PASS: gdb.python/py-objfile-script.exp: continue +PASS: gdb.python/py-objfile-script.exp: print ss +Running ./gdb.python/py-parameter.exp ... +PASS: gdb.python/py-parameter.exp: python print (gdb.parameter ('directories')) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "Show the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: enum gdb parameter - python +PASS: gdb.python/py-parameter.exp: enum gdb parameter - class TestEnumParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - show_doc = "Show the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - set_doc = "Set the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum is " + pvalue +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum has been set to " + self.value +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - super (TestEnumParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_ENUM, ["one", "two"]) +PASS: gdb.python/py-parameter.exp: enum gdb parameter - self.value = "one" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - test_enum_param = TestEnumParam ('print test-enum-param') +PASS: gdb.python/py-parameter.exp: enum gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Show parameter is initial value +PASS: gdb.python/py-parameter.exp: Set enum to two +PASS: gdb.python/py-parameter.exp: Show parameter is new value +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Set invalid enum parameter +PASS: gdb.python/py-parameter.exp: file gdb parameter - python +PASS: gdb.python/py-parameter.exp: file gdb parameter - class TestFileParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: file gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: file gdb parameter - show_doc = "Show the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - set_doc = "Set the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file is " + pvalue +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file has been changed to " + self.value +PASS: gdb.python/py-parameter.exp: file gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: file gdb parameter - super (TestFileParam, self).__init__ (name, gdb.COMMAND_FILES, gdb.PARAM_FILENAME) +PASS: gdb.python/py-parameter.exp: file gdb parameter - self.value = "foo.txt" +PASS: gdb.python/py-parameter.exp: file gdb parameter - test_file_param = TestFileParam ('test-file-param') +PASS: gdb.python/py-parameter.exp: file gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test file parameter value +PASS: gdb.python/py-parameter.exp: Show initial file value +PASS: gdb.python/py-parameter.exp: Set new file parameter +PASS: gdb.python/py-parameter.exp: Show new file value +PASS: gdb.python/py-parameter.exp: Test new file parameter value +PASS: gdb.python/py-parameter.exp: set test-file-param +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestUndocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestUndocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_undoc_param = TestUndocParam ('print test-undoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestNodocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestNodocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_nodoc_param = TestNodocParam ('print test-nodoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "State of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +Running ./gdb.python/py-pp-maint.exp ... +PASS: gdb.python/py-pp-maint.exp: b 77 +PASS: gdb.python/py-pp-maint.exp: continue +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt enabled #1 +PASS: gdb.python/py-pp-maint.exp: print ss enabled #1 +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt disabled +PASS: gdb.python/py-pp-maint.exp: print ss disabled +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*ss.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*s.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: print flt re-enabled +PASS: gdb.python/py-pp-maint.exp: print ss re-enabled +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | FLAG_3 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | 8 +Running ./gdb.python/py-prettyprint.exp ... +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +FAIL: gdb.python/py-prettyprint.exp: setting breakpoint at exit +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print cps +PASS: gdb.python/py-prettyprint.exp: print cpss +PASS: gdb.python/py-prettyprint.exp: print cpssa[0] +PASS: gdb.python/py-prettyprint.exp: print cpssa[1] +PASS: gdb.python/py-prettyprint.exp: print cpssa +PASS: gdb.python/py-prettyprint.exp: print sss +PASS: gdb.python/py-prettyprint.exp: print ref +PASS: gdb.python/py-prettyprint.exp: print derived +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +FAIL: gdb.python/py-prettyprint.exp: setting breakpoint at exit +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: continue to breakpoint: eval-break +PASS: gdb.python/py-prettyprint.exp: info locals +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: print ss enabled #1 +PASS: gdb.python/py-prettyprint.exp: python disable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss disabled +PASS: gdb.python/py-prettyprint.exp: python enable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss enabled #2 +Running ./gdb.python/py-progspace.exp ... +PASS: gdb.python/py-progspace.exp: current progspace filename (None) +PASS: gdb.python/py-progspace.exp: python print (gdb.progspaces()) +PASS: gdb.python/py-progspace.exp: current progspace filename (py-progspace) +Running ./gdb.python/py-prompt.exp ... +Running ./gdb.python/py-section-script.exp ... +PASS: gdb.python/py-section-script.exp: set auto-load safe-path +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts py-section-script +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts no-script-matches-this +PASS: gdb.python/py-section-script.exp: b 51 +PASS: gdb.python/py-section-script.exp: continue +PASS: gdb.python/py-section-script.exp: print ss +Running ./gdb.python/py-shared.exp ... +PASS: gdb.python/py-shared.exp: func1 address +FAIL: gdb.python/py-shared.exp: Aquire func1 address +FAIL: gdb.python/py-shared.exp: test func1 solib location +PASS: gdb.python/py-shared.exp: main address +PASS: gdb.python/py-shared.exp: Aquire main address +PASS: gdb.python/py-shared.exp: test main solib location +Running ./gdb.python/py-strfns.exp ... +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str2) +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str3) +PASS: gdb.python/py-strfns.exp: p $_strlen (str1) +PASS: gdb.python/py-strfns.exp: p $_strlen (buf1) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf2, 4) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf3, 4) +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Help") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello.$") +PASS: gdb.python/py-strfns.exp: condition $bpnum $_streq (arg, "Goodbye.") +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break func here. +PASS: gdb.python/py-strfns.exp: p arg +PASS: gdb.python/py-strfns.exp: condition $bpnum $_memeq (arg, buf3, 4) +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break bfunc here. +PASS: gdb.python/py-strfns.exp: p /d {char[4]} arg +PASS: gdb.python/py-strfns.exp: save a corefile +PASS: gdb.python/py-strfns.exp: re-load generated corefile +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str2) +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str3) +PASS: gdb.python/py-strfns.exp: p $_strlen (str1) +PASS: gdb.python/py-strfns.exp: p $_strlen (buf1) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf2, 4) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf3, 4) +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Help") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello.$") +Running ./gdb.python/py-symbol.exp ... +PASS: gdb.python/py-symbol.exp: Lookup main +PASS: gdb.python/py-symbol.exp: Test main_func.is_function +PASS: gdb.python/py-symbol.exp: Test lookup_global_symbol("junk") +PASS: gdb.python/py-symbol.exp: print value of main +PASS: gdb.python/py-symbol.exp: print line number of qq +PASS: gdb.python/py-symbol.exp: print value of qq +PASS: gdb.python/py-symbol.exp: print whether qq needs a frame +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symbol.exp: Test arg.is_variable +PASS: gdb.python/py-symbol.exp: Test arg.is_constant +PASS: gdb.python/py-symbol.exp: Test arg.is_argument +PASS: gdb.python/py-symbol.exp: Test arg.is_function +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test a.is_variable +PASS: gdb.python/py-symbol.exp: Test a.is_constant +PASS: gdb.python/py-symbol.exp: Test a.is_argument +PASS: gdb.python/py-symbol.exp: Test a.is_function +PASS: gdb.python/py-symbol.exp: Test a.addr_class +PASS: gdb.python/py-symbol.exp: try to print value of a without a frame +PASS: gdb.python/py-symbol.exp: print value of a +PASS: gdb.python/py-symbol.exp: print whether a needs a frame +PASS: gdb.python/py-symbol.exp: Test t.is_variable +PASS: gdb.python/py-symbol.exp: Test t.is_constant +PASS: gdb.python/py-symbol.exp: Test t.is_argument +PASS: gdb.python/py-symbol.exp: Test t.is_function +PASS: gdb.python/py-symbol.exp: Test t.addr_class +PASS: gdb.python/py-symbol.exp: Get type +PASS: gdb.python/py-symbol.exp: Get symtab +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break in class. +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol destructor +Running ./gdb.python/py-symtab.exp ... +PASS: gdb.python/py-symtab.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symtab.exp: Test symtab +PASS: gdb.python/py-symtab.exp: Test sal.pc +PASS: gdb.python/py-symtab.exp: Test sal.last +PASS: gdb.python/py-symtab.exp: Test sal.line +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.filename +PASS: gdb.python/py-symtab.exp: Test symtab.objfile +PASS: gdb.python/py-symtab.exp: Test symtab.fullname +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test qq in global symbols +PASS: gdb.python/py-symtab.exp: Test func in global symbols +PASS: gdb.python/py-symtab.exp: Test main in global symbols +PASS: gdb.python/py-symtab.exp: Test int in static symbols +PASS: gdb.python/py-symtab.exp: Test char in static symbols +PASS: gdb.python/py-symtab.exp: Test simple_struct in static symbols +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test sal destructor +PASS: gdb.python/py-symtab.exp: Test symtab destructor +Running ./gdb.python/py-template.exp ... +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const * +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile * const * volatile * +Running ./gdb.python/python.exp ... +PASS: gdb.python/python.exp: multi-line python command - python +PASS: gdb.python/python.exp: multi-line python command - print (23) +PASS: gdb.python/python.exp: multi-line python command - end +PASS: gdb.python/python.exp: show python command - define zzq +PASS: gdb.python/python.exp: show python command - python +PASS: gdb.python/python.exp: show python command - print (23) +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - show user zzq +PASS: gdb.python/python.exp: indented multi-line python command - python +PASS: gdb.python/python.exp: indented multi-line python command - def foo (): +PASS: gdb.python/python.exp: indented multi-line python command - print ('hello, world!') +PASS: gdb.python/python.exp: indented multi-line python command - foo () +PASS: gdb.python/python.exp: indented multi-line python command - end +PASS: gdb.python/python.exp: source source2.py +PASS: gdb.python/python.exp: source -s source2.py +PASS: gdb.python/python.exp: python print (gdb.current_objfile()) +PASS: gdb.python/python.exp: python print (gdb.objfiles()) +PASS: gdb.python/python.exp: pythonX.Y/lib-dynload/*.so +PASS: gdb.python/python.exp: python x = gdb.execute('printf "%d", 23', to_string = True) +PASS: gdb.python/python.exp: python print (x) +PASS: gdb.python/python.exp: post event insertion - python +PASS: gdb.python/python.exp: post event insertion - someVal = 0 +PASS: gdb.python/python.exp: post event insertion - class Foo(object): +PASS: gdb.python/python.exp: post event insertion - def __call__(self): +PASS: gdb.python/python.exp: post event insertion - global someVal +PASS: gdb.python/python.exp: post event insertion - someVal += 1 +PASS: gdb.python/python.exp: post event insertion - gdb.post_event(Foo()) +PASS: gdb.python/python.exp: post event insertion - end +PASS: gdb.python/python.exp: test post event execution +PASS: gdb.python/python.exp: Test non callable class +PASS: gdb.python/python.exp: show height +PASS: gdb.python/python.exp: set height 10 +PASS: gdb.python/python.exp: verify pagination beforehand +PASS: gdb.python/python.exp: verify pagination beforehand: q +PASS: gdb.python/python.exp: gdb.execute does not page +PASS: gdb.python/python.exp: verify pagination afterwards +PASS: gdb.python/python.exp: verify pagination afterwards: q +PASS: gdb.python/python.exp: set height 0 +PASS: gdb.python/python.exp: collect help from uiout +PASS: gdb.python/python.exp: verify help to uiout +PASS: gdb.python/python.exp: Attempt to aquire thread with no inferior +PASS: gdb.python/python.exp: Ensure that no threads are returned +PASS: gdb.python/python.exp: register atexit function - python +PASS: gdb.python/python.exp: register atexit function - import atexit +PASS: gdb.python/python.exp: register atexit function - def printit(arg): +PASS: gdb.python/python.exp: register atexit function - print (arg) +PASS: gdb.python/python.exp: register atexit function - atexit.register(printit, 'good bye world') +PASS: gdb.python/python.exp: register atexit function - end +PASS: gdb.python/python.exp: atexit handling +PASS: gdb.python/python.exp: test decode_line no source named main +PASS: gdb.python/python.exp: test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current locationn filename +PASS: gdb.python/python.exp: Test decode_line current location line number +PASS: gdb.python/python.exp: test decode_line python.c:26 +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line python.c:26 filename +PASS: gdb.python/python.exp: Test decode_line python.c:26 line number +PASS: gdb.python/python.exp: test decode_line randomfunc +PASS: gdb.python/python.exp: test decode_line func1() +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 filename +PASS: gdb.python/python.exp: Test decode_line func1 line number +PASS: gdb.python/python.exp: test decode_line func1,func2 +PASS: gdb.python/python.exp: stop at comma in linespec +PASS: gdb.python/python.exp: Test stderr location +PASS: gdb.python/python.exp: Test stdout location +PASS: gdb.python/python.exp: Test default write +PASS: gdb.python/python.exp: Test stderr write +PASS: gdb.python/python.exp: Test stdout write +PASS: gdb.python/python.exp: Test stdlog write +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: prompt substitution - python +PASS: gdb.python/python.exp: prompt substitution - someCounter = 0 +PASS: gdb.python/python.exp: prompt substitution - def prompt(current): +PASS: gdb.python/python.exp: prompt substitution - global someCounter +PASS: gdb.python/python.exp: prompt substitution - if (current == "testfake "): +PASS: gdb.python/python.exp: prompt substitution - return None +PASS: gdb.python/python.exp: prompt substitution - someCounter = someCounter + 1 +PASS: gdb.python/python.exp: prompt substitution - return "py prompt " + str (someCounter) + " " +PASS: gdb.python/python.exp: prompt substitution - end +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def program_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - global pCounter +PASS: gdb.python/python.exp: prompt substitution readline - if (current == ">"): +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = pCounter + 1 +PASS: gdb.python/python.exp: prompt substitution readline - return "python line " + str (pCounter) + ": " +PASS: gdb.python/python.exp: prompt substitution readline - return None +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set prompt testfake +PASS: gdb.python/python.exp: show prompt shows guarded prompt +PASS: gdb.python/python.exp: set prompt blah overriden +PASS: gdb.python/python.exp: Delete old hook +PASS: gdb.python/python.exp: set default prompt +PASS: gdb.python/python.exp: set programming hook +PASS: gdb.python/python.exp: readline secondary are not substituted +PASS: gdb.python/python.exp: end programming +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - import gdb.command.prompt +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set basic extended prompt +PASS: gdb.python/python.exp: set extended prompt working directory +PASS: gdb.python/python.exp: set extended prompt parameter +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to none. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def error_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - raise RuntimeError("Python exception called") +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Get line number of func2 call site +PASS: gdb.python/python.exp: Test find_pc_line at func2 call site +PASS: gdb.python/python.exp: Step into func2 +PASS: gdb.python/python.exp: Step out of func2 +PASS: gdb.python/python.exp: Test find_pc_line with resume address +Running ./gdb.python/py-type.exp ... +PASS: gdb.python/py-type.exp: lang_c: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_c: test_fields: c typedef field list +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_c: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_c: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_c: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum fields items list +PASS: gdb.python/py-type.exp: lang_cpp: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: c++ typedef field list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (c) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from c.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field c name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field d name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type.fields()[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: print value (d) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: get value (d) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: extract type fields from d +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[0]) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[1]) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check correct tuple length +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get fields +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: Check range for non ranged type. +PASS: gdb.python/py-type.exp: lang_cpp: get type of temvar +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(0)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(0), gdb.Type)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(1)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(1), gdb.Value)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(2)) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum fields items list +Running ./gdb.python/py-typeprint.exp ... +PASS: gdb.python/py-typeprint.exp: python exec (open ('py-typeprint.py').read ()) +PASS: gdb.python/py-typeprint.exp: basic test +PASS: gdb.python/py-typeprint.exp: raw test +PASS: gdb.python/py-typeprint.exp: disable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with disabled printer +PASS: gdb.python/py-typeprint.exp: info type-printers +PASS: gdb.python/py-typeprint.exp: enable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with enabled printer +PASS: gdb.python/py-typeprint.exp: whatis s +Running ./gdb.python/py-value-cc.exp ... +PASS: gdb.python/py-value-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").dereference().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().dereference())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().referenced_value())) +Running ./gdb.python/py-value.exp ... +PASS: gdb.python/py-value.exp: create boolean value +PASS: gdb.python/py-value.exp: create integer value +PASS: gdb.python/py-value.exp: create long value +PASS: gdb.python/py-value.exp: create double value +PASS: gdb.python/py-value.exp: create 8-bit string value +PASS: gdb.python/py-value.exp: print 8-bit string +PASS: gdb.python/py-value.exp: verify type of 8-bit string +PASS: gdb.python/py-value.exp: create unicode value +PASS: gdb.python/py-value.exp: print Unicode string +PASS: gdb.python/py-value.exp: verify type of unicode string +PASS: gdb.python/py-value.exp: Test address attribute in non-addressable value +PASS: gdb.python/py-value.exp: add two integer values +PASS: gdb.python/py-value.exp: verify type of integer add result +PASS: gdb.python/py-value.exp: add two double values +PASS: gdb.python/py-value.exp: subtract two integer values +PASS: gdb.python/py-value.exp: subtract two double values +PASS: gdb.python/py-value.exp: multiply two integer values +PASS: gdb.python/py-value.exp: multiply two double values +PASS: gdb.python/py-value.exp: divide two integer values +PASS: gdb.python/py-value.exp: divide two double values +PASS: gdb.python/py-value.exp: take remainder of two integer values +PASS: gdb.python/py-value.exp: integer value raised to the power of another integer value +PASS: gdb.python/py-value.exp: double value raised to the power of integer value +PASS: gdb.python/py-value.exp: negated integer value +PASS: gdb.python/py-value.exp: positive integer value +PASS: gdb.python/py-value.exp: negated double value +PASS: gdb.python/py-value.exp: positive double value +PASS: gdb.python/py-value.exp: absolute of integer value +PASS: gdb.python/py-value.exp: absolute of double value +PASS: gdb.python/py-value.exp: subtract integer value from python integer +PASS: gdb.python/py-value.exp: verify type of mixed integer subtraction result +PASS: gdb.python/py-value.exp: add double value with python float +PASS: gdb.python/py-value.exp: subtract python integer from integer value +PASS: gdb.python/py-value.exp: add python float with double value +PASS: gdb.python/py-value.exp: print evalue +PASS: gdb.python/py-value.exp: python evalue = gdb.history (0) +PASS: gdb.python/py-value.exp: python print (int (evalue)) +PASS: gdb.python/py-value.exp: add pointer value with python integer +PASS: gdb.python/py-value.exp: subtract python integer from pointer value +PASS: gdb.python/py-value.exp: subtract two pointer values +PASS: gdb.python/py-value.exp: catch error in python type conversion +PASS: gdb.python/py-value.exp: catch throw of GDB error +PASS: gdb.python/py-value.exp: define function to test booleans - python +PASS: gdb.python/py-value.exp: define function to test booleans - def test_bool (val): +PASS: gdb.python/py-value.exp: define function to test booleans - if val: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('yay') +PASS: gdb.python/py-value.exp: define function to test booleans - else: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('nay') +PASS: gdb.python/py-value.exp: define function to test booleans - end +PASS: gdb.python/py-value.exp: check evaluation of true boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of false boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: less than, equal +PASS: gdb.python/py-value.exp: less than, less +PASS: gdb.python/py-value.exp: less than, greater +PASS: gdb.python/py-value.exp: less than, None +PASS: gdb.python/py-value.exp: less or equal, equal +PASS: gdb.python/py-value.exp: less or equal, less +PASS: gdb.python/py-value.exp: less or equal, greater +PASS: gdb.python/py-value.exp: less or equal, None +PASS: gdb.python/py-value.exp: equality of gdb.Values +PASS: gdb.python/py-value.exp: inequality of gdb.Values +PASS: gdb.python/py-value.exp: equality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with None +PASS: gdb.python/py-value.exp: inequality, false +PASS: gdb.python/py-value.exp: inequality, true +PASS: gdb.python/py-value.exp: inequality, None +PASS: gdb.python/py-value.exp: greater than, equal +PASS: gdb.python/py-value.exp: greater than, less +PASS: gdb.python/py-value.exp: greater than, greater +PASS: gdb.python/py-value.exp: greater than, None +PASS: gdb.python/py-value.exp: greater or equal, equal +PASS: gdb.python/py-value.exp: greater or equal, less +PASS: gdb.python/py-value.exp: greater or equal, greater +PASS: gdb.python/py-value.exp: greater or equal, None +PASS: gdb.python/py-value.exp: py-value in file.filename +PASS: gdb.python/py-value.exp: python print (gdb.objfiles()[0].pretty_printers) +PASS: gdb.python/py-value.exp: python gdb.objfiles()[0].pretty_printers = 0 +PASS: gdb.python/py-value.exp: parse_and_eval constant test +PASS: gdb.python/py-value.exp: parse_and_eval simple expression test +PASS: gdb.python/py-value.exp: parse_and_eval type test +PASS: gdb.python/py-value.exp: Simple Python value dictionary - python +PASS: gdb.python/py-value.exp: Simple Python value dictionary - one = gdb.Value(1) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - two = gdb.Value(2) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - three = gdb.Value(3) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - vdict = {one:"one str",two:"two str",three:"three str"} +PASS: gdb.python/py-value.exp: Simple Python value dictionary - end +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test inbuilt hash +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: access element inside struct using 8-bit string name +PASS: gdb.python/py-value.exp: access element inside struct using unicode name +PASS: gdb.python/py-value.exp: dereference value +PASS: gdb.python/py-value.exp: Test is_optimized_out attribute +PASS: gdb.python/py-value.exp: Test address attribute +PASS: gdb.python/py-value.exp: parse_and_eval with memory error +PASS: gdb.python/py-value.exp: python inval = gdb.parse_and_eval('*(int*)0') +PASS: gdb.python/py-value.exp: python print (inval.is_lazy) +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: python argc_lazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy.fetch_lazy() +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: python print (argc_notlazy.is_lazy) +PASS: gdb.python/py-value.exp: sanity check argc +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: set argc=2 +PASS: gdb.python/py-value.exp: python print (argc_notlazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: print st +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string with no length +PASS: gdb.python/py-value.exp: Test string (length = -1) is all of the string +PASS: gdb.python/py-value.exp: python print (st.string (length = 6)) +PASS: gdb.python/py-value.exp: Test string (length = 0) is empty +PASS: gdb.python/py-value.exp: Test length is 0 +PASS: gdb.python/py-value.exp: print nullst +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string to first null +PASS: gdb.python/py-value.exp: get string beyond null +PASS: gdb.python/py-value.exp: python print (repr(nullst)) +PASS: gdb.python/py-value.exp: p/x fp1 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp1 = fp1.dereference() +PASS: gdb.python/py-value.exp: python result = fp1() +PASS: gdb.python/py-value.exp: python print (result) +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp2 = fp2.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp2(10,20) +PASS: gdb.python/py-value.exp: python print (result2) +PASS: gdb.python/py-value.exp: p i +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python result3 = i() +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp3 = fp3.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp3(10) +PASS: gdb.python/py-value.exp: print sptr +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Aquire lazy string +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: print sn +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Test lazy string +PASS: gdb.python/py-value.exp: Succesfully create a lazy string +PASS: gdb.python/py-value.exp: Test lazy string length +PASS: gdb.python/py-value.exp: Test lazy string address +PASS: gdb.python/py-value.exp: create PTR type +PASS: gdb.python/py-value.exp: kill the inferior +PASS: gdb.python/py-value.exp: Discard the symbols +PASS: gdb.python/py-value.exp: cast arg0 to PTR +PASS: gdb.python/py-value.exp: delete PTR type +PASS: gdb.python/py-value.exp: print value's type +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect pointer by reference +PASS: gdb.python/py-value.exp: Obtain address +PASS: gdb.python/py-value.exp: Obtains value from GDB +PASS: gdb.python/py-value.exp: Check pointer passed as reference +PASS: gdb.python/py-value.exp: python print (bool(gdb.parse_and_eval('base').dynamic_cast(gdb.lookup_type('Derived').pointer()))) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('base').dynamic_type) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('5').dynamic_type) +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +Running ./gdb.reverse/amd64-tailcall-reverse.exp ... +Running ./gdb.reverse/break-precsave.exp ... +Running ./gdb.reverse/break-reverse.exp ... +Running ./gdb.reverse/consecutive-precsave.exp ... +Running ./gdb.reverse/consecutive-reverse.exp ... +Running ./gdb.reverse/finish-precsave.exp ... +Running ./gdb.reverse/finish-reverse-bkpt.exp ... +Running ./gdb.reverse/finish-reverse.exp ... +Running ./gdb.reverse/i386-precsave.exp ... +Running ./gdb.reverse/i386-reverse.exp ... +Running ./gdb.reverse/i386-sse-reverse.exp ... +Running ./gdb.reverse/i387-env-reverse.exp ... +Running ./gdb.reverse/i387-stack-reverse.exp ... +Running ./gdb.reverse/machinestate.exp ... +Running ./gdb.reverse/machinestate-precsave.exp ... +Running ./gdb.reverse/next-reverse-bkpt-over-sr.exp ... +Running ./gdb.reverse/sigall-precsave.exp ... +Running ./gdb.reverse/sigall-reverse.exp ... +Running ./gdb.reverse/singlejmp-reverse.exp ... +Running ./gdb.reverse/solib-precsave.exp ... +Running ./gdb.reverse/solib-reverse.exp ... +Running ./gdb.reverse/step-precsave.exp ... +Running ./gdb.reverse/step-reverse.exp ... +Running ./gdb.reverse/until-precsave.exp ... +Running ./gdb.reverse/until-reverse.exp ... +Running ./gdb.reverse/watch-precsave.exp ... +Running ./gdb.reverse/watch-reverse.exp ... +Running ./gdb.server/ext-attach.exp ... +Running ./gdb.server/ext-run.exp ... +PASS: gdb.server/ext-run.exp: disconnect +PASS: gdb.server/ext-run.exp: set remote exec-file +PASS: gdb.server/ext-run.exp: continue to main +PASS: gdb.server/ext-run.exp: get process list +PASS: gdb.server/ext-run.exp: kill +PASS: gdb.server/ext-run.exp: load new file without any gdbserver inferior +PASS: gdb.server/ext-run.exp: monitor exit +Running ./gdb.server/file-transfer.exp ... +PASS: gdb.server/file-transfer.exp: disconnect +FAIL: gdb.server/file-transfer.exp: put binary file +FAIL: gdb.server/file-transfer.exp: get binary file +FAIL: gdb.server/file-transfer.exp: compare binary file +FAIL: gdb.server/file-transfer.exp: deleted binary file +FAIL: gdb.server/file-transfer.exp: put text file +FAIL: gdb.server/file-transfer.exp: get text file +FAIL: gdb.server/file-transfer.exp: compare text file +FAIL: gdb.server/file-transfer.exp: deleted text file +Running ./gdb.server/no-thread-db.exp ... +PASS: gdb.server/no-thread-db.exp: successfully compiled posix threads test case +PASS: gdb.server/no-thread-db.exp: disconnect +PASS: gdb.server/no-thread-db.exp: libthread-db is now unresolvable +FAIL: gdb.server/no-thread-db.exp: continue to breakpoint: after tls assignment +FAIL: gdb.server/no-thread-db.exp: print foo +Running ./gdb.server/server-exec-info.exp ... +PASS: gdb.server/server-exec-info.exp: file +PASS: gdb.server/server-exec-info.exp: set sysroot remote: +PASS: gdb.server/server-exec-info.exp: info files +Running ./gdb.server/server-kill.exp ... +PASS: gdb.server/server-kill.exp: disconnect +FAIL: gdb.server/server-kill.exp: tstatus +Running ./gdb.server/server-mon.exp ... +PASS: gdb.server/server-mon.exp: disconnect +PASS: gdb.server/server-mon.exp: monitor help +PASS: gdb.server/server-mon.exp: monitor +PASS: gdb.server/server-mon.exp: monitor set debug 1 +PASS: gdb.server/server-mon.exp: monitor set debug 0 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 1 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 0 +Running ./gdb.server/server-run.exp ... +PASS: gdb.server/server-run.exp: disconnect +PASS: gdb.server/server-run.exp: loaded dynamic linker +PASS: gdb.server/server-run.exp: continue to main +Running ./gdb.server/solib-list.exp ... +Running ./gdb.stabs/exclfwd.exp ... +PASS: gdb.stabs/exclfwd.exp: ptype v1 +PASS: gdb.stabs/exclfwd.exp: ptype v2 +PASS: gdb.stabs/exclfwd.exp: ptype v3 +Running ./gdb.stabs/gdb11479.exp ... +PASS: gdb.stabs/gdb11479.exp: Set breakpoints forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: Set breakpoints natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test natural_debug_format +Running ./gdb.stabs/weird.exp ... +PASS: gdb.stabs/weird.exp: weirdx.o read without error +PASS: gdb.stabs/weird.exp: stabs found +PASS: gdb.stabs/weird.exp: variable var0 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var0) +PASS: gdb.stabs/weird.exp: variable var1 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var1) +PASS: gdb.stabs/weird.exp: variable var2 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var2) +PASS: gdb.stabs/weird.exp: variable var3 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var3) +PASS: gdb.stabs/weird.exp: variable attr32 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr32) +PASS: gdb.stabs/weird.exp: variable attr33 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr33) +PASS: gdb.stabs/weird.exp: variable attr35 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr35) +PASS: gdb.stabs/weird.exp: variable attr36 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr36) +PASS: gdb.stabs/weird.exp: variable attr37 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr37) +PASS: gdb.stabs/weird.exp: variable attr38 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr38) +PASS: gdb.stabs/weird.exp: variable attr39 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr39) +PASS: gdb.stabs/weird.exp: variable attr41 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr41) +PASS: gdb.stabs/weird.exp: variable attr42 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr42) +PASS: gdb.stabs/weird.exp: variable attr43 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr43) +PASS: gdb.stabs/weird.exp: variable attr44 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr44) +PASS: gdb.stabs/weird.exp: variable attr46 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr46) +PASS: gdb.stabs/weird.exp: variable attr47 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr47) +PASS: gdb.stabs/weird.exp: variable attr58 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr58) +PASS: gdb.stabs/weird.exp: variable attr59 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr59) +PASS: gdb.stabs/weird.exp: variable attr60 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr60) +PASS: gdb.stabs/weird.exp: variable attr61 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr61) +PASS: gdb.stabs/weird.exp: variable attr62 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr62) +PASS: gdb.stabs/weird.exp: variable attr63 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr63) +PASS: gdb.stabs/weird.exp: variable attr64 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr64) +PASS: gdb.stabs/weird.exp: variable attr65 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr65) +PASS: gdb.stabs/weird.exp: variable attr66 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr66) +PASS: gdb.stabs/weird.exp: variable attr67 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr67) +PASS: gdb.stabs/weird.exp: variable attr68 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr68) +PASS: gdb.stabs/weird.exp: variable attr69 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr69) +PASS: gdb.stabs/weird.exp: variable attr70 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr70) +PASS: gdb.stabs/weird.exp: variable attr71 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr71) +PASS: gdb.stabs/weird.exp: variable attr72 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr72) +PASS: gdb.stabs/weird.exp: variable attr73 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr73) +PASS: gdb.stabs/weird.exp: variable attr74 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr74) +PASS: gdb.stabs/weird.exp: variable attr75 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr75) +PASS: gdb.stabs/weird.exp: variable attr76 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr76) +PASS: gdb.stabs/weird.exp: variable attr77 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr77) +PASS: gdb.stabs/weird.exp: variable attr78 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr78) +PASS: gdb.stabs/weird.exp: variable attr79 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr79) +PASS: gdb.stabs/weird.exp: variable attr80 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr80) +PASS: gdb.stabs/weird.exp: variable attr81 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr81) +PASS: gdb.stabs/weird.exp: variable attr82 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr82) +PASS: gdb.stabs/weird.exp: variable attr83 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr83) +PASS: gdb.stabs/weird.exp: variable attr84 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr84) +PASS: gdb.stabs/weird.exp: variable attr85 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr85) +PASS: gdb.stabs/weird.exp: variable attr86 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr86) +PASS: gdb.stabs/weird.exp: variable attr87 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr87) +PASS: gdb.stabs/weird.exp: variable attr88 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr88) +PASS: gdb.stabs/weird.exp: variable attr89 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr89) +PASS: gdb.stabs/weird.exp: variable attr90 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr90) +PASS: gdb.stabs/weird.exp: variable attr91 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr91) +PASS: gdb.stabs/weird.exp: variable attr92 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr92) +PASS: gdb.stabs/weird.exp: variable attr93 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr93) +PASS: gdb.stabs/weird.exp: variable attr94 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr94) +PASS: gdb.stabs/weird.exp: variable attr95 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr95) +PASS: gdb.stabs/weird.exp: variable attr96 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr96) +PASS: gdb.stabs/weird.exp: variable attr97 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr97) +PASS: gdb.stabs/weird.exp: variable attr98 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr98) +PASS: gdb.stabs/weird.exp: variable attr99 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr99) +PASS: gdb.stabs/weird.exp: variable attr100 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr100) +PASS: gdb.stabs/weird.exp: variable attr101 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr101) +PASS: gdb.stabs/weird.exp: variable attr102 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr102) +PASS: gdb.stabs/weird.exp: variable attr103 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr103) +PASS: gdb.stabs/weird.exp: variable attr104 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr104) +PASS: gdb.stabs/weird.exp: variable attr105 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr105) +PASS: gdb.stabs/weird.exp: variable attr106 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr106) +PASS: gdb.stabs/weird.exp: variable attr107 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr107) +PASS: gdb.stabs/weird.exp: variable attr108 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr108) +PASS: gdb.stabs/weird.exp: variable attr109 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr109) +PASS: gdb.stabs/weird.exp: variable attr110 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr110) +PASS: gdb.stabs/weird.exp: variable attr111 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr111) +PASS: gdb.stabs/weird.exp: variable attr112 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr112) +PASS: gdb.stabs/weird.exp: variable attr113 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr113) +PASS: gdb.stabs/weird.exp: variable attr114 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr114) +PASS: gdb.stabs/weird.exp: variable attr115 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr115) +PASS: gdb.stabs/weird.exp: variable attr116 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr116) +PASS: gdb.stabs/weird.exp: variable attr117 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr117) +PASS: gdb.stabs/weird.exp: variable attr118 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr118) +PASS: gdb.stabs/weird.exp: variable attr119 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr119) +PASS: gdb.stabs/weird.exp: variable attr120 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr120) +PASS: gdb.stabs/weird.exp: variable attr121 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr121) +PASS: gdb.stabs/weird.exp: variable attr122 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr122) +PASS: gdb.stabs/weird.exp: variable attr123 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr123) +PASS: gdb.stabs/weird.exp: variable attr124 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr124) +PASS: gdb.stabs/weird.exp: variable attr125 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr125) +PASS: gdb.stabs/weird.exp: variable attr126 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr126) +PASS: gdb.stabs/weird.exp: 'e' constant on non-enum type +PASS: gdb.stabs/weird.exp: whatis const69 +PASS: gdb.stabs/weird.exp: 'e' constant with embedded type +PASS: gdb.stabs/weird.exp: char constant +PASS: gdb.stabs/weird.exp: String constant 1 +PASS: gdb.stabs/weird.exp: String constant 2 +PASS: gdb.stabs/weird.exp: String constant 3 +PASS: gdb.stabs/weird.exp: String constant 4 +PASS: gdb.stabs/weird.exp: p bad_neg0 +PASS: gdb.stabs/weird.exp: ptype on inttype +PASS: gdb.stabs/weird.exp: unrecognized floating point type +PASS: gdb.stabs/weird.exp: print very big integer +PASS: gdb.stabs/weird.exp: whatis consth +PASS: gdb.stabs/weird.exp: whatis consth2 +XFAIL: gdb.stabs/weird.exp: print struct constant +PASS: gdb.stabs/weird.exp: print bad_type0 +PASS: gdb.stabs/weird.exp: print bad_type1 +XFAIL: gdb.stabs/weird.exp: array0 with strange index +XFAIL: gdb.stabs/weird.exp: array1 with strange index +PASS: gdb.stabs/weird.exp: whatis one_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis one_var test 2 +PASS: gdb.stabs/weird.exp: whatis two_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis two_var test 2 +XFAIL: gdb.stabs/weird.exp: whatis pointer_to_int_var +XFAIL: gdb.stabs/weird.exp: whatis intp_var +PASS: gdb.stabs/weird.exp: p common0var0 +XFAIL: gdb.stabs/weird.exp: p common0var1 +XFAIL: gdb.stabs/weird.exp: p common0var2 +Running ./gdb.threads/attach-into-signal.exp ... +Running ./gdb.threads/attach-stopped.exp ... +Running ./gdb.threads/bp_in_thread.exp ... +PASS: gdb.threads/bp_in_thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/bp_in_thread.exp: breakpoint on noreturn +PASS: gdb.threads/bp_in_thread.exp: run to noreturn +Running ./gdb.threads/clone-new-thread-event.exp ... +PASS: gdb.threads/clone-new-thread-event.exp: catch SIGUSR1 +Running ./gdb.threads/corethreads.exp ... +Running ./gdb.threads/create-fail.exp ... +PASS: gdb.threads/create-fail.exp: successfully compiled posix threads test case +FAIL: gdb.threads/create-fail.exp: iteration 1: run till end +FAIL: gdb.threads/create-fail.exp: iteration 2: run till end +FAIL: gdb.threads/create-fail.exp: iteration 3: run till end +FAIL: gdb.threads/create-fail.exp: iteration 4: run till end +FAIL: gdb.threads/create-fail.exp: iteration 5: run till end +FAIL: gdb.threads/create-fail.exp: iteration 6: run till end +FAIL: gdb.threads/create-fail.exp: iteration 7: run till end +FAIL: gdb.threads/create-fail.exp: iteration 8: run till end +FAIL: gdb.threads/create-fail.exp: iteration 9: run till end +FAIL: gdb.threads/create-fail.exp: iteration 10: run till end +Running ./gdb.threads/current-lwp-dead.exp ... +PASS: gdb.threads/current-lwp-dead.exp: continue to breakpoint: fn_return +Running ./gdb.threads/execl.exp ... +Running ./gdb.threads/fork-child-threads.exp ... +Running ./gdb.threads/fork-thread-pending.exp ... +Running ./gdb.threads/gcore-thread.exp ... +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: help gcore +PASS: gdb.threads/gcore-thread.exp: thread 1 is running +PASS: gdb.threads/gcore-thread.exp: thread 2 is running +PASS: gdb.threads/gcore-thread.exp: save a corefile +XFAIL: gdb.threads/gcore-thread.exp: clear __stack_user.next +XFAIL: gdb.threads/gcore-thread.exp: clear stack_used.next +PASS: gdb.threads/gcore-thread.exp: corefile: re-load generated corefile +PASS: gdb.threads/gcore-thread.exp: corefile: corefile contains at least two threads +PASS: gdb.threads/gcore-thread.exp: corefile: a corefile thread is executing thread2 +PASS: gdb.threads/gcore-thread.exp: corefile: thread2 is current thread in corefile +FAIL: gdb.threads/gcore-thread.exp: core0file: re-load generated corefile +FAIL: gdb.threads/gcore-thread.exp: core0file: corefile contains at least two threads +FAIL: gdb.threads/gcore-thread.exp: core0file: a corefile thread is executing thread2 +FAIL: gdb.threads/gcore-thread.exp: core0file: thread2 is current thread in corefile +Running ./gdb.threads/hand-call-in-threads.exp ... +PASS: gdb.threads/hand-call-in-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on hand_call +PASS: gdb.threads/hand-call-in-threads.exp: run to all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: enable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking on +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: set confirm off +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: all dummies popped +PASS: gdb.threads/hand-call-in-threads.exp: disable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking off +Running ./gdb.threads/ia64-sigill.exp ... +PASS: gdb.threads/ia64-sigill.exp: successfully compiled posix threads test case +PASS: gdb.threads/ia64-sigill.exp: info addr label +PASS: gdb.threads/ia64-sigill.exp: set $sigill_bpnum=$bpnum +PASS: gdb.threads/ia64-sigill.exp: set debug infrun 1 +PASS: gdb.threads/ia64-sigill.exp: continue +PASS: gdb.threads/ia64-sigill.exp: delete $sigill_bpnum +PASS: gdb.threads/ia64-sigill.exp: continue for the pending signal +Running ./gdb.threads/interrupted-hand-call.exp ... +PASS: gdb.threads/interrupted-hand-call.exp: successfully compiled posix threads test case +PASS: gdb.threads/interrupted-hand-call.exp: breakpoint on all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: run to all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/interrupted-hand-call.exp: dummy stack frame present +PASS: gdb.threads/interrupted-hand-call.exp: finish hand-call +PASS: gdb.threads/interrupted-hand-call.exp: dummy frame popped +FAIL: gdb.threads/interrupted-hand-call.exp: setting breakpoint at exit +Running ./gdb.threads/killed.exp ... +PASS: gdb.threads/killed.exp: successfully compiled posix threads test case +PASS: gdb.threads/killed.exp: run program to completion +PASS: gdb.threads/killed.exp: GDB exits after multi-threaded program exits messily +Running ./gdb.threads/leader-exit.exp ... +PASS: gdb.threads/leader-exit.exp: successfully compiled posix threads test case +FAIL: gdb.threads/leader-exit.exp: continue to breakpoint: break-here (timeout) +FAIL: gdb.threads/leader-exit.exp: Single thread has been left (timeout) +Running ./gdb.threads/linux-dp.exp ... +PASS: gdb.threads/linux-dp.exp: successfully compiled posix threads test case +PASS: gdb.threads/linux-dp.exp: set print sevenbit-strings +PASS: gdb.threads/linux-dp.exp: info threads 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 0 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 0 +PASS: gdb.threads/linux-dp.exp: info threads after: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 1 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 1 +PASS: gdb.threads/linux-dp.exp: info threads after: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 2 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 2 +PASS: gdb.threads/linux-dp.exp: info threads after: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 3 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 3 +PASS: gdb.threads/linux-dp.exp: info threads after: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 4 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 4 +PASS: gdb.threads/linux-dp.exp: info threads after: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/linux-dp.exp: info threads 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print +FAIL: gdb.threads/linux-dp.exp: first thread-specific breakpoint hit +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 5 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 6 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 7 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 8 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 9 +PASS: gdb.threads/linux-dp.exp: thread-specific breakpoint is thread-specific +PASS: gdb.threads/linux-dp.exp: selected thread: 1 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 1 +PASS: gdb.threads/linux-dp.exp: selected thread: 2 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 2 +PASS: gdb.threads/linux-dp.exp: selected thread: 3 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 3 +PASS: gdb.threads/linux-dp.exp: selected thread: 4 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 4 +PASS: gdb.threads/linux-dp.exp: selected thread: 5 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 5 +PASS: gdb.threads/linux-dp.exp: selected thread: 6 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 6 +PASS: gdb.threads/linux-dp.exp: found an interesting thread +PASS: gdb.threads/linux-dp.exp: manager thread found (not found) when expected +Running ./gdb.threads/local-watch-wrong-thread.exp ... +Running ./gdb.threads/manythreads.exp ... +PASS: gdb.threads/manythreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/manythreads.exp: set print sevenbit-strings +PASS: gdb.threads/manythreads.exp: shell stty intr '^C' +PASS: gdb.threads/manythreads.exp: first continue +PASS: gdb.threads/manythreads.exp: stop threads 1 +PASS: gdb.threads/manythreads.exp: info threads +PASS: gdb.threads/manythreads.exp: give a name to the thread +PASS: gdb.threads/manythreads.exp: check thread name +PASS: gdb.threads/manythreads.exp: second continue +PASS: gdb.threads/manythreads.exp: check for duplicate SIGINT +PASS: gdb.threads/manythreads.exp: stop threads 2 +PASS: gdb.threads/manythreads.exp: GDB exits after stopping multithreaded program +Running ./gdb.threads/multi-create.exp ... +PASS: gdb.threads/multi-create.exp: successfully compiled posix threads test case +PASS: gdb.threads/multi-create.exp: continue to breakpoint 0 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 1 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 2 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 3 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 4 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 5 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 6 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 7 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 8 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 9 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 10 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 11 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 12 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 13 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 14 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 15 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 16 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 17 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 18 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 19 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 20 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 21 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 22 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 23 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 24 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 25 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 26 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 27 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 28 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 29 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 30 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 31 +Running ./gdb.threads/non-ldr-exc-1.exp ... +Running ./gdb.threads/non-ldr-exc-2.exp ... +Running ./gdb.threads/non-ldr-exc-3.exp ... +Running ./gdb.threads/non-ldr-exc-4.exp ... +Running ./gdb.threads/no-unwaited-for-left.exp ... +PASS: gdb.threads/no-unwaited-for-left.exp: successfully compiled posix threads test case +PASS: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here +PASS: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for thread 2 +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when thread 2 exits (the program exited) +FAIL: gdb.threads/no-unwaited-for-left.exp: only main thread left, thread 2 terminated +PASS: gdb.threads/no-unwaited-for-left.exp: select main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: disable scheduler-locking, letting new thread start +FAIL: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here-2 +FAIL: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when the main thread exits (the program is no longer running) +FAIL: gdb.threads/no-unwaited-for-left.exp: only thread 3 left, main thread terminated +Running ./gdb.threads/pending-step.exp ... +PASS: gdb.threads/pending-step.exp: successfully compiled posix threads test case +PASS: gdb.threads/pending-step.exp: continue to breakpoint: continue to first breakpoint hit +PASS: gdb.threads/pending-step.exp: next in multiple threads with breakpoints +Running ./gdb.threads/print-threads.exp ... +PASS: gdb.threads/print-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/print-threads.exp: set print sevenbit-strings +PASS: gdb.threads/print-threads.exp: set width 0 +PASS: gdb.threads/print-threads.exp: shell stty intr '^C' +PASS: gdb.threads/print-threads.exp: break thread_function +PASS: gdb.threads/print-threads.exp: set var slow = 0 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (fast) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (fast) +PASS: gdb.threads/print-threads.exp: break thread_function (2) +PASS: gdb.threads/print-threads.exp: set var slow = 1 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow) +PASS: gdb.threads/print-threads.exp: break thread_function (3) +PASS: gdb.threads/print-threads.exp: set var slow = 1 (2) +FAIL: gdb.threads/print-threads.exp: setting breakpoint at kill +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow with kill breakpoint) +Running ./gdb.threads/pthread_cond_wait.exp ... +PASS: gdb.threads/pthread_cond_wait.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthread_cond_wait.exp: breakpoint on break_me +PASS: gdb.threads/pthread_cond_wait.exp: run to break_me +FAIL: gdb.threads/pthread_cond_wait.exp: backtrace in blocked thread +Running ./gdb.threads/pthreads.exp ... +PASS: gdb.threads/pthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthreads.exp: set print sevenbit-strings +PASS: gdb.threads/pthreads.exp: set width 0 +PASS: gdb.threads/pthreads.exp: shell stty intr '^C' +PASS: gdb.threads/pthreads.exp: info threads +PASS: gdb.threads/pthreads.exp: break thread1 +PASS: gdb.threads/pthreads.exp: Continue to creation of first thread +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: break thread2 +PASS: gdb.threads/pthreads.exp: Continue to creation of second thread +PASS: gdb.threads/pthreads.exp: set var common_routine::hits=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after startup +PASS: gdb.threads/pthreads.exp: Continue with all threads running +PASS: gdb.threads/pthreads.exp: Stopped with a ^C +PASS: gdb.threads/pthreads.exp: bt +FAIL: gdb.threads/pthreads.exp: set var common_routine::hits=0 +FAIL: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +FAIL: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +FAIL: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +FAIL: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after continuing from ^C stop +FAIL: gdb.threads/pthreads.exp: check backtrace from main thread +FAIL: gdb.threads/pthreads.exp: check backtrace from thread 1 +FAIL: gdb.threads/pthreads.exp: check backtrace from thread 2 +FAIL: gdb.threads/pthreads.exp: apply backtrace command to all three threads +PASS: gdb.threads/pthreads.exp: set break at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: continue to bkpt at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: backtrace from thread 2 bkpt in common_routine +Running ./gdb.threads/schedlock.exp ... +PASS: gdb.threads/schedlock.exp: successfully compiled posix threads test case +PASS: gdb.threads/schedlock.exp: shell stty intr '^C' +PASS: gdb.threads/schedlock.exp: set print sevenbit-strings +PASS: gdb.threads/schedlock.exp: set width 0 +PASS: gdb.threads/schedlock.exp: scheduler locking set to none +PASS: gdb.threads/schedlock.exp: continue to breakpoint: all threads started +PASS: gdb.threads/schedlock.exp: listed args (1) +PASS: gdb.threads/schedlock.exp: continue (initial) +PASS: gdb.threads/schedlock.exp: stop all threads (initial) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (initial) +PASS: gdb.threads/schedlock.exp: listed args (2) +PASS: gdb.threads/schedlock.exp: all threads alive +PASS: gdb.threads/schedlock.exp: find current thread (1) +PASS: gdb.threads/schedlock.exp: set scheduler-locking off +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 0) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 1) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 2) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 3) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 4) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 5) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 6) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 7) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 8) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step without lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (3) +PASS: gdb.threads/schedlock.exp: current thread stepped +PASS: gdb.threads/schedlock.exp: other threads ran - unlocked +PASS: gdb.threads/schedlock.exp: set scheduler-locking on +PASS: gdb.threads/schedlock.exp: continue (with lock) +PASS: gdb.threads/schedlock.exp: stop all threads (with lock) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (with lock) +PASS: gdb.threads/schedlock.exp: find current thread (3) +PASS: gdb.threads/schedlock.exp: continue with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (4) +PASS: gdb.threads/schedlock.exp: current thread ran +PASS: gdb.threads/schedlock.exp: other threads didn't run - locked +PASS: gdb.threads/schedlock.exp: step to increment (locked 0) +PASS: gdb.threads/schedlock.exp: step to increment (locked 1) +PASS: gdb.threads/schedlock.exp: step to increment (locked 2) +PASS: gdb.threads/schedlock.exp: step to increment (locked 3) +PASS: gdb.threads/schedlock.exp: step to increment (locked 4) +PASS: gdb.threads/schedlock.exp: step to increment (locked 5) +PASS: gdb.threads/schedlock.exp: step to increment (locked 6) +PASS: gdb.threads/schedlock.exp: step to increment (locked 7) +PASS: gdb.threads/schedlock.exp: step to increment (locked 8) +PASS: gdb.threads/schedlock.exp: step to increment (locked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (5) +PASS: gdb.threads/schedlock.exp: current thread stepped locked +PASS: gdb.threads/schedlock.exp: other threads didn't run - step locked +Running ./gdb.threads/siginfo-threads.exp ... +PASS: gdb.threads/siginfo-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR1 stop print pass +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR2 stop print pass +PASS: gdb.threads/siginfo-threads.exp: get pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 0 +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 1 +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 2 +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 3 +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_pid +PASS: gdb.threads/siginfo-threads.exp: continue to breakpoint: break-at-exit +Running ./gdb.threads/sigstep-threads.exp ... +PASS: gdb.threads/sigstep-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigstep-threads.exp: handle SIGUSR1 nostop print pass +PASS: gdb.threads/sigstep-threads.exp: set scheduler-locking off +PASS: gdb.threads/sigstep-threads.exp: set $step1=$bpnum +PASS: gdb.threads/sigstep-threads.exp: continue to breakpoint: step-1 +PASS: gdb.threads/sigstep-threads.exp: disable $step1 +PASS: gdb.threads/sigstep-threads.exp: step +Running ./gdb.threads/sigthread.exp ... +PASS: gdb.threads/sigthread.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigthread.exp: handle SIGUSR1 nostop noprint pass +PASS: gdb.threads/sigthread.exp: handle SIGUSR2 nostop noprint pass +PASS: gdb.threads/sigthread.exp: continue +PASS: gdb.threads/sigthread.exp: stop with control-c +Running ./gdb.threads/staticthreads.exp ... +PASS: gdb.threads/staticthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/staticthreads.exp: set print sevenbit-strings +PASS: gdb.threads/staticthreads.exp: break sem_post +PASS: gdb.threads/staticthreads.exp: Continue to main's call of sem_post +PASS: gdb.threads/staticthreads.exp: rerun to main +PASS: gdb.threads/staticthreads.exp: handle SIG32 nostop noprint pass +PASS: gdb.threads/staticthreads.exp: handle SIG32 helps +PASS: gdb.threads/staticthreads.exp: info threads +PASS: gdb.threads/staticthreads.exp: GDB exits with static thread program +Running ./gdb.threads/switch-threads.exp ... +PASS: gdb.threads/switch-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/switch-threads.exp: continue to breakpoint: continue to thread_func +PASS: gdb.threads/switch-threads.exp: next +Running ./gdb.threads/threadapply.exp ... +PASS: gdb.threads/threadapply.exp: successfully compiled posix threads test case +PASS: gdb.threads/threadapply.exp: b 62 +PASS: gdb.threads/threadapply.exp: continue +PASS: gdb.threads/threadapply.exp: macro details +PASS: gdb.threads/threadapply.exp: defining macro +PASS: gdb.threads/threadapply.exp: set backtrace limit 3 +PASS: gdb.threads/threadapply.exp: thread apply all backthread +PASS: gdb.threads/threadapply.exp: step to the thread_function +PASS: gdb.threads/threadapply.exp: go up in the stack frame +PASS: gdb.threads/threadapply.exp: run a simple print command on all threads +PASS: gdb.threads/threadapply.exp: go down and check selected frame +Running ./gdb.threads/thread_check.exp ... +PASS: gdb.threads/thread_check.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread_check.exp: breakpoint at tf +PASS: gdb.threads/thread_check.exp: continue to tf +PASS: gdb.threads/thread_check.exp: backtrace from thread function +Running ./gdb.threads/thread_events.exp ... +Running ./gdb.threads/thread-execl.exp ... +Running ./gdb.threads/thread-find.exp ... +PASS: gdb.threads/thread-find.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-find.exp: set print sevenbit-strings +PASS: gdb.threads/thread-find.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/thread-find.exp: info threads +PASS: gdb.threads/thread-find.exp: name thread 1 +PASS: gdb.threads/thread-find.exp: name thread 2 +PASS: gdb.threads/thread-find.exp: name thread 3 +PASS: gdb.threads/thread-find.exp: name thread 4 +PASS: gdb.threads/thread-find.exp: name thread 5 +PASS: gdb.threads/thread-find.exp: name thread 6 +PASS: gdb.threads/thread-find.exp: collect thread id +PASS: gdb.threads/thread-find.exp: got thread ids +PASS: gdb.threads/thread-find.exp: collect process id +PASS: gdb.threads/thread-find.exp: collect lwp id +PASS: gdb.threads/thread-find.exp: find thread name 6 +PASS: gdb.threads/thread-find.exp: find thread name 5 +PASS: gdb.threads/thread-find.exp: find thread name 4 +PASS: gdb.threads/thread-find.exp: find thread name 3 +PASS: gdb.threads/thread-find.exp: find thread name 2 +PASS: gdb.threads/thread-find.exp: find thread name 1 +PASS: gdb.threads/thread-find.exp: find thread id 6 +PASS: gdb.threads/thread-find.exp: find thread id 5 +PASS: gdb.threads/thread-find.exp: find thread id 4 +PASS: gdb.threads/thread-find.exp: find thread id 3 +PASS: gdb.threads/thread-find.exp: find thread id 2 +PASS: gdb.threads/thread-find.exp: find thread id 1 +PASS: gdb.threads/thread-find.exp: no thread +PASS: gdb.threads/thread-find.exp: test regular exp +PASS: gdb.threads/thread-find.exp: info threads 2 4 6 +PASS: gdb.threads/thread-find.exp: info threads 3-5 +PASS: gdb.threads/thread-find.exp: test inverted range +PASS: gdb.threads/thread-find.exp: info threads 3-3 +PASS: gdb.threads/thread-find.exp: info thread foo +PASS: gdb.threads/thread-find.exp: info thread foo -1 +Running ./gdb.threads/thread-specific.exp ... +PASS: gdb.threads/thread-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-specific.exp: set print sevenbit-strings +PASS: gdb.threads/thread-specific.exp: set width 0 +PASS: gdb.threads/thread-specific.exp: thread var when not running +PASS: gdb.threads/thread-specific.exp: continue to breakpoint: all threads started +PASS: gdb.threads/thread-specific.exp: get threads list +PASS: gdb.threads/thread-specific.exp: thread var in main +PASS: gdb.threads/thread-specific.exp: breakpoint 59 main thread +PASS: gdb.threads/thread-specific.exp: continue to thread-specific breakpoint +PASS: gdb.threads/thread-specific.exp: found breakpoint for thread number +PASS: gdb.threads/thread-specific.exp: thread var at break +Running ./gdb.threads/thread-unwindonsignal.exp ... +PASS: gdb.threads/thread-unwindonsignal.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-unwindonsignal.exp: breakpoint on all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: run to all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: setting unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: showing unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/thread-unwindonsignal.exp: dummy stack frame present +FAIL: gdb.threads/thread-unwindonsignal.exp: wrong thread not unwound +PASS: gdb.threads/thread-unwindonsignal.exp: finish hand-call +PASS: gdb.threads/thread-unwindonsignal.exp: dummy frame popped +FAIL: gdb.threads/thread-unwindonsignal.exp: setting breakpoint at exit +Running ./gdb.threads/threxit-hop-specific.exp ... +PASS: gdb.threads/threxit-hop-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/threxit-hop-specific.exp: continue to thread start +PASS: gdb.threads/threxit-hop-specific.exp: set thread specific breakpoint +PASS: gdb.threads/threxit-hop-specific.exp: get past the thread specific breakpoint +Running ./gdb.threads/tls.exp ... +PASS: gdb.threads/tls.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls.exp: set breakpoint at all threads +PASS: gdb.threads/tls.exp: set breakpoint at synch point +PASS: gdb.threads/tls.exp: set breakpoint at exit +PASS: gdb.threads/tls.exp: continue to first thread: get to thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at first th +PASS: gdb.threads/tls.exp: first thread print me +FAIL: gdb.threads/tls.exp: first thread local storage +FAIL: gdb.threads/tls.exp: first another thread local storage +PASS: gdb.threads/tls.exp: first info address a_thread_local +PASS: gdb.threads/tls.exp: first info address another_thread_local +PASS: gdb.threads/tls.exp: continue to second thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at second th +PASS: gdb.threads/tls.exp: second thread print me +FAIL: gdb.threads/tls.exp: second thread local storage +FAIL: gdb.threads/tls.exp: second another thread local storage +PASS: gdb.threads/tls.exp: second info address a_thread_local +PASS: gdb.threads/tls.exp: second info address another_thread_local +PASS: gdb.threads/tls.exp: continue to third thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at third th +PASS: gdb.threads/tls.exp: third thread print me +FAIL: gdb.threads/tls.exp: third thread local storage +FAIL: gdb.threads/tls.exp: third another thread local storage +PASS: gdb.threads/tls.exp: third info address a_thread_local +PASS: gdb.threads/tls.exp: third info address another_thread_local +PASS: gdb.threads/tls.exp: continue to synch point +PASS: gdb.threads/tls.exp: get number of threads +PASS: gdb.threads/tls.exp: selected thread: 1 +PASS: gdb.threads/tls.exp: backtrace of thread number 1 not relevant +PASS: gdb.threads/tls.exp: selected thread: 2 +PASS: gdb.threads/tls.exp: backtrace of thread number 2 not relevant +PASS: gdb.threads/tls.exp: selected thread: 3 +PASS: gdb.threads/tls.exp: backtrace of thread number 3 not relevant +PASS: gdb.threads/tls.exp: selected thread: 4 +PASS: gdb.threads/tls.exp: backtrace of thread number 4 not relevant +FAIL: gdb.threads/tls.exp: No thread backtrace reported spin (vsyscall kernel problem?) +PASS: gdb.threads/tls.exp: threads exited +PASS: gdb.threads/tls.exp: Expect only base thread at end +PASS: gdb.threads/tls.exp: info address a_global +FAIL: gdb.threads/tls.exp: info address me +FAIL: gdb.threads/tls.exp: p a_thread_local +FAIL: gdb.threads/tls.exp: p file2_thread_local +PASS: gdb.threads/tls.exp: info address file2_thread_local +FAIL: gdb.threads/tls.exp: p a_thread_local second time +PASS: gdb.threads/tls.exp: info address a_thread_local +Running ./gdb.threads/tls-nodebug.exp ... +PASS: gdb.threads/tls-nodebug.exp: successfully compiled posix threads test case +FAIL: gdb.threads/tls-nodebug.exp: thread local storage +Running ./gdb.threads/tls-shared.exp ... +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +FAIL: gdb.threads/tls-shared.exp: print thread local storage variable +PASS: gdb.threads/tls-shared.exp: ptype of thread local storage variable +PASS: gdb.threads/tls-shared.exp: print storage info for thread local storage variable +PASS: gdb.threads/tls-shared.exp: break at and of main +PASS: gdb.threads/tls-shared.exp: continue to break +PASS: gdb.threads/tls-shared.exp: print result +Running ./gdb.threads/tls-var.exp ... +PASS: gdb.threads/tls-var.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-var.exp: whatis tls_var +FAIL: gdb.threads/tls-var.exp: print tls_var +Running ./gdb.threads/watchpoint-fork.exp ... +KFAIL: gdb.threads/watchpoint-fork.exp: gdbserver does not support debugging across fork (PRMS: remote/13584) +Running ./gdb.threads/watchthreads2.exp ... +Running ./gdb.threads/watchthreads.exp ... +Running ./gdb.threads/watchthreads-reorder.exp ... +Running ./gdb.trace/actions.exp ... +PASS: gdb.trace/actions.exp: 5.1a: set three tracepoints, no actions +PASS: gdb.trace/actions.exp: 5.1b: set actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.1c: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.1d: set actions for second tracepoint +PASS: gdb.trace/actions.exp: 5.1e: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.2a: set actions for last (default) tracepoint +PASS: gdb.trace/actions.exp: 5.2b: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.3a: reset actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.3b: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.4: 'end' command out of context +PASS: gdb.trace/actions.exp: 5.5a: set empty actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.5c: verify NO actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.6: actions for invalid tracepoint number +PASS: gdb.trace/actions.exp: 5.7: invalid action +PASS: gdb.trace/actions.exp: 5.8a: help actions +PASS: gdb.trace/actions.exp: 5.8b: help collect +PASS: gdb.trace/actions.exp: 5.8c: help while-stepping +PASS: gdb.trace/actions.exp: 5.8d: help end +PASS: gdb.trace/actions.exp: 5.9a: set default-collect +PASS: gdb.trace/actions.exp: 5.9b: show default-collect +PASS: gdb.trace/actions.exp: 5.9c: set default-collect +PASS: gdb.trace/actions.exp: Create a trace state variable +PASS: gdb.trace/actions.exp: 5.10a: set teval action for first tracepoint +PASS: gdb.trace/actions.exp: 5.10a: set teval action for second tracepoint +PASS: gdb.trace/actions.exp: 5.10a: verify teval actions set for two tracepoints +Running ./gdb.trace/ax.exp ... +PASS: gdb.trace/ax.exp: maint agent 12 +PASS: gdb.trace/ax.exp: maint agent gdb_char_test +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test < &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval 12 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_char_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test < &gdb_short_test +Running ./gdb.trace/backtrace.exp ... +UNSUPPORTED: gdb.trace/backtrace.exp: Current target does not support trace +Running ./gdb.trace/change-loc.exp ... +UNSUPPORTED: gdb.trace/change-loc.exp: Current target does not support trace +Running ./gdb.trace/circ.exp ... +PASS: gdb.trace/circ.exp: set circular-trace-buffer on +PASS: gdb.trace/circ.exp: show circular-trace-buffer (on) +PASS: gdb.trace/circ.exp: set circular-trace-buffer off +PASS: gdb.trace/circ.exp: show circular-trace-buffer (off) +UNSUPPORTED: gdb.trace/circ.exp: Current target does not support trace +Running ./gdb.trace/collection.exp ... +UNSUPPORTED: gdb.trace/collection.exp: Current target does not support trace +Running ./gdb.trace/deltrace.exp ... +PASS: gdb.trace/deltrace.exp: set tracepoint 1 +PASS: gdb.trace/deltrace.exp: set tracepoint 2 +PASS: gdb.trace/deltrace.exp: set tracepoint 3 +PASS: gdb.trace/deltrace.exp: 3.1a: set three tracepoints +PASS: gdb.trace/deltrace.exp: 3.1b: delete all tracepoints +PASS: gdb.trace/deltrace.exp: 3.2a: set three tracepoints +PASS: gdb.trace/deltrace.exp: 3.2b: delete first tracepoint +PASS: gdb.trace/deltrace.exp: 3.2c: verify delete first tracepoint +PASS: gdb.trace/deltrace.exp: 3.2d: delete second tracepoint +PASS: gdb.trace/deltrace.exp: 3.2e: verify delete second tracepoint +PASS: gdb.trace/deltrace.exp: 3.2f: delete third tracepoint +PASS: gdb.trace/deltrace.exp: 3.2g: verify delete third tracepoint +PASS: gdb.trace/deltrace.exp: 3.3a: set three tracepoints +PASS: gdb.trace/deltrace.exp: 3.3b: delete three tracepoints +PASS: gdb.trace/deltrace.exp: 3.3c: verify delete three tracepoints +PASS: gdb.trace/deltrace.exp: 3.4: delete invalid tracepoint number +PASS: gdb.trace/deltrace.exp: 3.5: delete tracepoint number zero +PASS: gdb.trace/deltrace.exp: 3.6: help delete tracepoints +Running ./gdb.trace/disconnected-tracing.exp ... +UNSUPPORTED: gdb.trace/disconnected-tracing.exp: target does not support trace +Running ./gdb.trace/ftrace.exp ... +UNSUPPORTED: gdb.trace/ftrace.exp: target does not support trace +Running ./gdb.trace/infotrace.exp ... +PASS: gdb.trace/infotrace.exp: 2.1: info tracepoints (all) +PASS: gdb.trace/infotrace.exp: 2.2a: info tracepoint 1 (gdb_c_test) +PASS: gdb.trace/infotrace.exp: 2.2b: info tracepoint 2 (gdb_asm_test) +PASS: gdb.trace/infotrace.exp: 2.3: info tracepoint (invalid tracepoint number) +PASS: gdb.trace/infotrace.exp: 2.4: info trace rejects multiple tracepoint numbers +PASS: gdb.trace/infotrace.exp: 2.5: help info tracepoints +PASS: gdb.trace/infotrace.exp: collect on tracepoint 1 +UNSUPPORTED: gdb.trace/infotrace.exp: Current target does not support trace +Running ./gdb.trace/mi-traceframe-changed.exp ... +ERROR: remote_download to host of to basic.tf: cp: missing destination file operand after 'basic.tf' +Try 'cp --help' for more information. +UNRESOLVED: gdb.trace/mi-traceframe-changed.exp: tfile: select trace file +FAIL: gdb.trace/mi-traceframe-changed.exp: tfile: tfind 0 +FAIL: gdb.trace/mi-traceframe-changed.exp: tfile: tfind 0 again +FAIL: gdb.trace/mi-traceframe-changed.exp: tfile: tfind end +FAIL: gdb.trace/mi-traceframe-changed.exp: tfile: -trace-find frame-number 0 +UNSUPPORTED: gdb.trace/mi-traceframe-changed.exp: Current target does not support trace +Running ./gdb.trace/mi-tracepoint-changed.exp ... +UNSUPPORTED: gdb.trace/mi-tracepoint-changed.exp: Current target does not support trace +Running ./gdb.trace/mi-tsv-changed.exp ... +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: tvariable $tvar1 +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: tvariable $tvar1 modified +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: tvariable $tvar1 modified without notification +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: tvariable $tvar2 +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: delete tvariable $tvar2 +PASS: gdb.trace/mi-tsv-changed.exp: create delete modify: delete all tvariables +UNSUPPORTED: gdb.trace/mi-tsv-changed.exp: create delete modify: Current target does not support trace +UNSUPPORTED: gdb.trace/mi-tsv-changed.exp: Current target does not support trace +Running ./gdb.trace/packetlen.exp ... +UNSUPPORTED: gdb.trace/packetlen.exp: Current target does not support trace +Running ./gdb.trace/passc-dyn.exp ... +UNSUPPORTED: gdb.trace/passc-dyn.exp: Current target does not support trace +Running ./gdb.trace/passcount.exp ... +PASS: gdb.trace/passcount.exp: 4.1a: set three tracepoints, passcounts all zero +PASS: gdb.trace/passcount.exp: 4.1b: set 1st tracepoint's passcount to two +PASS: gdb.trace/passcount.exp: 4.1c: verify 1st tracepoint's passcount set to two +PASS: gdb.trace/passcount.exp: 4.1d: set 2nd tracepoint's passcount to four +PASS: gdb.trace/passcount.exp: 4.1c: verify 2nd tracepoint's passcount set to four +PASS: gdb.trace/passcount.exp: 4.2b: set last (default) tp's passcount to six +PASS: gdb.trace/passcount.exp: 4.2b: verify last (default) tp's passcount set to six +PASS: gdb.trace/passcount.exp: 4.4a: reset last (default) tp's passcount to seven +PASS: gdb.trace/passcount.exp: 4.4a: verify reset last (default) tp's passcount to seven +PASS: gdb.trace/passcount.exp: 4.4b: reset second tracepoint's passcount to five +PASS: gdb.trace/passcount.exp: 4.4c: verify reset second tracepoint's passcount to five +PASS: gdb.trace/passcount.exp: 4.20a: set all three passcounts to three +PASS: gdb.trace/passcount.exp: 4.20a: set all three passcounts to three +PASS: gdb.trace/passcount.exp: 4.20a: reset all three passcounts to four +PASS: gdb.trace/passcount.exp: 4.20b: reset all three passcounts to four +PASS: gdb.trace/passcount.exp: 4.6: set passcount to zero +PASS: gdb.trace/passcount.exp: 4.6: set passcount to zero +PASS: gdb.trace/passcount.exp: 4.7: set passcount to large number (32767) +PASS: gdb.trace/passcount.exp: 4.7: set passcount to large number (32767) +PASS: gdb.trace/passcount.exp: 4.8: invalid tracepoint number in passcount +PASS: gdb.trace/passcount.exp: 4.9: help passcount +Running ./gdb.trace/pending.exp ... +UNSUPPORTED: gdb.trace/pending.exp: Current target does not support trace +Running ./gdb.trace/qtro.exp ... +PASS: gdb.trace/qtro.exp: probe for target remote +UNSUPPORTED: gdb.trace/qtro.exp: Current target does not support trace +Running ./gdb.trace/report.exp ... +UNSUPPORTED: gdb.trace/report.exp: Current target does not support trace +Running ./gdb.trace/save-trace.exp ... +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 1 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 1 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 1 +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 2 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 2 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 2 +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 3 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 3 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 3 +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 4 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 4 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 4 +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 5 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 5 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 5 +PASS: gdb.trace/save-trace.exp: 10.x: set passcount for tracepoint 6 +PASS: gdb.trace/save-trace.exp: 10.x: set condition for tracepoint 6 +PASS: gdb.trace/save-trace.exp: 10.x: set actions for tracepoint 6 +PASS: gdb.trace/save-trace.exp: 10: set default-collect +PASS: gdb.trace/save-trace.exp: 10.x: verify trace setup +PASS: gdb.trace/save-trace.exp: 10: show default-collect +PASS: gdb.trace/save-trace.exp: 10.1: save tracepoint definitions +PASS: gdb.trace/save-trace.exp: 10.2: clear default-collect +PASS: gdb.trace/save-trace.exp: 10.2: delete tracepoints +PASS: gdb.trace/save-trace.exp: 10.2: read back saved tracepoints +PASS: gdb.trace/save-trace.exp: 10.2: verify recovered tracepoints +PASS: gdb.trace/save-trace.exp: 10: show default-collect +PASS: gdb.trace/save-trace.exp: 10.3: save tracepoint definitions, full path +PASS: gdb.trace/save-trace.exp: 10.3: clear default-collect +PASS: gdb.trace/save-trace.exp: 10.3: delete tracepoints +PASS: gdb.trace/save-trace.exp: 10.4: read saved tracepoints, full path +PASS: gdb.trace/save-trace.exp: 10.3: verify recovered tracepoints, full path +PASS: gdb.trace/save-trace.exp: 10: show default-collect +PASS: gdb.trace/save-trace.exp: 10.7: help save-tracepoints +Running ./gdb.trace/stap-trace.exp ... +Running ./gdb.trace/status-stop.exp ... +UNSUPPORTED: gdb.trace/status-stop.exp: target does not support trace +Running ./gdb.trace/strace.exp ... +UNTESTED: gdb.trace/strace.exp: UST library or headers are not installed +Running ./gdb.trace/tfile.exp ... +ERROR: remote_download to host of to basic.tf: cp: missing destination file operand after 'basic.tf' +Try 'cp --help' for more information. +ERROR: remote_download to host of to error.tf: cp: missing destination file operand after 'error.tf' +Try 'cp --help' for more information. +UNRESOLVED: gdb.trace/tfile.exp: target tfile +FAIL: gdb.trace/tfile.exp: info tracepoints on trace file +FAIL: gdb.trace/tfile.exp: tfind 0 on trace file +PASS: gdb.trace/tfile.exp: print testglob on trace file +PASS: gdb.trace/tfile.exp: print testglob2 on trace file +PASS: gdb.trace/tfile.exp: print constglob on trace file +PASS: gdb.trace/tfile.exp: tfind does not find a second frame in trace file +FAIL: gdb.trace/tfile.exp: tstatus on trace file +PASS: gdb.trace/tfile.exp: leave tfind mode +PASS: gdb.trace/tfile.exp: no stack if no traceframe selected +PASS: gdb.trace/tfile.exp: no registers if no traceframe selected +FAIL: gdb.trace/tfile.exp: target tfile +FAIL: gdb.trace/tfile.exp: tstatus on error trace file +FAIL: gdb.trace/tfile.exp: interpreter-exec mi "-target-select tfile basic.tf" +FAIL: gdb.trace/tfile.exp: -trace-status +Running ./gdb.trace/tfind.exp ... +PASS: gdb.trace/tfind.exp: 6.2: help tstart +PASS: gdb.trace/tfind.exp: 7.2: help tstop +PASS: gdb.trace/tfind.exp: 8.38: help tfind +PASS: gdb.trace/tfind.exp: 8.38: help tfind PC +PASS: gdb.trace/tfind.exp: 8.38: help tfind end +PASS: gdb.trace/tfind.exp: 8.38: help tfind none +PASS: gdb.trace/tfind.exp: 8.38: help tfind line +PASS: gdb.trace/tfind.exp: 8.38: help tfind start +PASS: gdb.trace/tfind.exp: 8.38: help tfind range +PASS: gdb.trace/tfind.exp: 8.38: help tfind tracepoint +UNSUPPORTED: gdb.trace/tfind.exp: Current target does not support trace +Running ./gdb.trace/trace-break.exp ... +UNSUPPORTED: gdb.trace/trace-break.exp: target does not support trace +Running ./gdb.trace/trace-buffer-size.exp ... +UNSUPPORTED: gdb.trace/trace-buffer-size.exp: target does not support trace +Running ./gdb.trace/tracecmd.exp ... +PASS: gdb.trace/tracecmd.exp: 1.0: help tracepoints +PASS: gdb.trace/tracecmd.exp: 1.1a: set tracepoint at sourceline +PASS: gdb.trace/tracecmd.exp: 1.1b: trace sourcefile:line +PASS: gdb.trace/tracecmd.exp: set breakpoint pending off +PASS: gdb.trace/tracecmd.exp: 1.2a: trace invalid line in sourcefile +PASS: gdb.trace/tracecmd.exp: 1.2b: reject invalid line in srcfile +PASS: gdb.trace/tracecmd.exp: 1.3a: trace invalid source file +PASS: gdb.trace/tracecmd.exp: 1.3b: reject invalid srcfile +PASS: gdb.trace/tracecmd.exp: 1.4a: trace function by name +PASS: gdb.trace/tracecmd.exp: 1.4b: trace function by name +PASS: gdb.trace/tracecmd.exp: 1.5a: trace invalid function +PASS: gdb.trace/tracecmd.exp: 1.5b: reject invalid srcfile +PASS: gdb.trace/tracecmd.exp: 1.6a: trace at specific address +PASS: gdb.trace/tracecmd.exp: 1.6b: verify trace at specific address +PASS: gdb.trace/tracecmd.exp: 1.7a: trace at function label (before prologue) +PASS: gdb.trace/tracecmd.exp: 1.7b: verify trace at specific address +PASS: gdb.trace/tracecmd.exp: 1.9: trace <no arguments> +PASS: gdb.trace/tracecmd.exp: 1.11a: conditional tracepoint +PASS: gdb.trace/tracecmd.exp: 1.11b: verify conditional tracepoint +PASS: gdb.trace/tracecmd.exp: 1.14: help trace +PASS: gdb.trace/tracecmd.exp: Set a fast tracepoint +Running ./gdb.trace/trace-mt.exp ... +PASS: gdb.trace/trace-mt.exp: successfully compiled posix threads test case +UNSUPPORTED: gdb.trace/trace-mt.exp: target does not support trace +Running ./gdb.trace/tspeed.exp ... +gdb compile failed, armv7a-cros-linux-gnueabi-gcc.real: error: /var/tmp/portage/cross-armv7a-cros-linux-gnueabi/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../gdbserver/libinproctrace.so: No such file or directory +UNTESTED: gdb.trace/tspeed.exp: tspeed.exp +Running ./gdb.trace/tstatus.exp ... +UNSUPPORTED: gdb.trace/tstatus.exp: target does not support trace +Running ./gdb.trace/tsv.exp ... +PASS: gdb.trace/tsv.exp: Create a trace state variable +PASS: gdb.trace/tsv.exp: Create a trace state variable with initial value +PASS: gdb.trace/tsv.exp: Change initial value of a trace state variable +PASS: gdb.trace/tsv.exp: Create a trace state variable with expression +PASS: gdb.trace/tsv.exp: Init trace state variable to a 64-bit value +PASS: gdb.trace/tsv.exp: tvariable syntax error, not empty variable name +PASS: gdb.trace/tsv.exp: tvariable syntax error, bad name +PASS: gdb.trace/tsv.exp: tvariable syntax error, bad name 2 +PASS: gdb.trace/tsv.exp: tvariable syntax error, bad name 3 +PASS: gdb.trace/tsv.exp: tvariable syntax error, not an assignment +PASS: gdb.trace/tsv.exp: tvariable creation fails with invalid expression +PASS: gdb.trace/tsv.exp: List tvariables +PASS: gdb.trace/tsv.exp: Print a trace state variable before run +PASS: gdb.trace/tsv.exp: delete trace state variable +PASS: gdb.trace/tsv.exp: List tvariables after deletion +PASS: gdb.trace/tsv.exp: Delete all trace state variables +PASS: gdb.trace/tsv.exp: List tvariables after deleting all +UNSUPPORTED: gdb.trace/tsv.exp: Current target does not support trace +Running ./gdb.trace/unavailable.exp ... +UNSUPPORTED: gdb.trace/unavailable.exp: Current target does not support trace +Running ./gdb.trace/while-dyn.exp ... +UNSUPPORTED: gdb.trace/while-dyn.exp: Current target does not support trace +Running ./gdb.trace/while-stepping.exp ... +PASS: gdb.trace/while-stepping.exp: 5.12: set a tracepoint, stepcount is zero +PASS: gdb.trace/while-stepping.exp: 5.12: set stepcount to 12 +PASS: gdb.trace/while-stepping.exp: 5.12: info trace shows "while-stepping" +PASS: gdb.trace/while-stepping.exp: 5.14: while-stepping null stepcount +PASS: gdb.trace/while-stepping.exp: 5.15: while-stepping rejects zero stepcount +PASS: gdb.trace/while-stepping.exp: 5.16: step without collecting anything +PASS: gdb.trace/while-stepping.exp: 5.16: confirm actions, step without collecting anything +Running ./gdb.xml/tdesc-arch.exp ... +PASS: gdb.xml/tdesc-arch.exp: read valid architectures +PASS: gdb.xml/tdesc-arch.exp: read default architecture +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (first architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (first architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (second architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (second architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (invalid architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (invalid architecture) +Running ./gdb.xml/tdesc-errors.exp ... +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-bogus.xml +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-unknown.xml +Running ./gdb.xml/tdesc-regs.exp ... +PASS: gdb.xml/tdesc-regs.exp: set tdesc file single-reg.xml +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from extra-regs.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +PASS: gdb.xml/tdesc-regs.exp: ptype $uintreg +PASS: gdb.xml/tdesc-regs.exp: ptype $vecreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $bitfields +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from core-only.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +Running ./gdb.xml/tdesc-xinclude.exp ... +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/includes.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/bad-include.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/loop.xml + + === gdb Summary === + +# of expected passes 17017 +# of unexpected failures 610 +# of unexpected successes 1 +# of expected failures 32 +# of known failures 41 +# of untested testcases 56 +# of unresolved testcases 4 +# of unsupported tests 131 +/var/tmp/portage/cross-armv7a-cros-linux-gnueabi/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb version 7.6.1 -nw -nx -data-directory /var/tmp/portage/cross-armv7a-cros-linux-gnueabi/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../data-directory + diff --git a/deprecated/dejagnu/gdb_baseline/i686-pc-linux-gnu b/deprecated/dejagnu/gdb_baseline/i686-pc-linux-gnu new file mode 100644 index 00000000..e3e1ee7c --- /dev/null +++ b/deprecated/dejagnu/gdb_baseline/i686-pc-linux-gnu @@ -0,0 +1,19167 @@ +Test Run By yunlian on Fri Dec 27 14:14:24 2013 +Target is i686-pc-linux-gnu + + === gdb tests === + +Schedule of variations: + x86-alex + +Running target x86-alex +Running ./gdb.ada/aliased_array.exp ... +UNSUPPORTED: gdb.ada/aliased_array.exp: compilation foo.adb +Running ./gdb.ada/array_bounds.exp ... +UNSUPPORTED: gdb.ada/array_bounds.exp: compilation bar.adb +Running ./gdb.ada/arrayidx.exp ... +UNSUPPORTED: gdb.ada/arrayidx.exp: compilation p.adb +Running ./gdb.ada/arrayparam.exp ... +UNSUPPORTED: gdb.ada/arrayparam.exp: compilation foo.adb +Running ./gdb.ada/arrayptr.exp ... +UNSUPPORTED: gdb.ada/arrayptr.exp: compilation foo.adb +Running ./gdb.ada/array_return.exp ... +UNSUPPORTED: gdb.ada/array_return.exp: compilation p.adb +Running ./gdb.ada/array_subscript_addr.exp ... +UNSUPPORTED: gdb.ada/array_subscript_addr.exp: compilation p.adb +Running ./gdb.ada/assign_1.exp ... +PASS: gdb.ada/assign_1.exp: Changing the language to ada +PASS: gdb.ada/assign_1.exp: set convenience variable $xxx to 1 +Running ./gdb.ada/atomic_enum.exp ... +UNSUPPORTED: gdb.ada/atomic_enum.exp: compilation foo.adb +Running ./gdb.ada/bad-task-bp-keyword.exp ... +UNSUPPORTED: gdb.ada/bad-task-bp-keyword.exp: compilation foo.adb +Running ./gdb.ada/boolean_expr.exp ... +PASS: gdb.ada/boolean_expr.exp: Changing the language to ada +PASS: gdb.ada/boolean_expr.exp: print 1 = 2 +PASS: gdb.ada/boolean_expr.exp: print 3 = 3 +Running ./gdb.ada/bp_enum_homonym.exp ... +UNSUPPORTED: gdb.ada/bp_enum_homonym.exp: compilation p.adb +Running ./gdb.ada/bp_on_var.exp ... +UNSUPPORTED: gdb.ada/bp_on_var.exp: compilation foo.adb +Running ./gdb.ada/bp_range_type.exp ... +UNSUPPORTED: gdb.ada/bp_range_type.exp: compilation foo.adb +Running ./gdb.ada/bp_reset.exp ... +UNSUPPORTED: gdb.ada/bp_reset.exp: compilation foo.adb +Running ./gdb.ada/call_pn.exp ... +UNSUPPORTED: gdb.ada/call_pn.exp: compilation foo.adb +Running ./gdb.ada/catch_ex.exp ... +UNSUPPORTED: gdb.ada/catch_ex.exp: compilation foo.adb +Running ./gdb.ada/char_enum.exp ... +UNSUPPORTED: gdb.ada/char_enum.exp: compilation foo.adb +Running ./gdb.ada/char_param.exp ... +UNSUPPORTED: gdb.ada/char_param.exp: compilation foo.adb +Running ./gdb.ada/complete.exp ... +UNSUPPORTED: gdb.ada/complete.exp: compilation foo.adb +Running ./gdb.ada/cond_lang.exp ... +UNSUPPORTED: gdb.ada/cond_lang.exp: compilation a.adb +Running ./gdb.ada/dyn_loc.exp ... +UNSUPPORTED: gdb.ada/dyn_loc.exp: compilation p.adb +Running ./gdb.ada/enum_idx_packed.exp ... +UNSUPPORTED: gdb.ada/enum_idx_packed.exp: compilation foo.adb +Running ./gdb.ada/exec_changed.exp ... +UNTESTED: gdb.ada/exec_changed.exp: exec_changed.exp +Running ./gdb.ada/expr_delims.exp ... +UNSUPPORTED: gdb.ada/expr_delims.exp: compilation foo.adb +Running ./gdb.ada/exprs.exp ... +UNSUPPORTED: gdb.ada/exprs.exp: compilation p.adb +Running ./gdb.ada/fixed_cmp.exp ... +UNSUPPORTED: gdb.ada/fixed_cmp.exp: compilation fixed.adb +Running ./gdb.ada/fixed_points.exp ... +UNSUPPORTED: gdb.ada/fixed_points.exp: compilation fixed_points.adb +Running ./gdb.ada/formatted_ref.exp ... +UNSUPPORTED: gdb.ada/formatted_ref.exp: compilation formatted_ref.adb +UNTESTED: gdb.ada/formatted_ref.exp: formatted-ref.exp +Running ./gdb.ada/frame_args.exp ... +UNSUPPORTED: gdb.ada/frame_args.exp: compilation foo.adb +Running ./gdb.ada/fullname_bp.exp ... +UNSUPPORTED: gdb.ada/fullname_bp.exp: compilation foo.adb +Running ./gdb.ada/fun_addr.exp ... +UNSUPPORTED: gdb.ada/fun_addr.exp: compilation foo.adb +Running ./gdb.ada/funcall_param.exp ... +UNSUPPORTED: gdb.ada/funcall_param.exp: compilation foo.adb +Running ./gdb.ada/fun_in_declare.exp ... +UNSUPPORTED: gdb.ada/fun_in_declare.exp: compilation foo.adb +Running ./gdb.ada/homonym.exp ... +UNSUPPORTED: gdb.ada/homonym.exp: compilation homonym_main.adb +Running ./gdb.ada/info_locals_renaming.exp ... +UNSUPPORTED: gdb.ada/info_locals_renaming.exp: compilation foo.adb +Running ./gdb.ada/info_types.exp ... +PASS: gdb.ada/info_types.exp: set lang ada +PASS: gdb.ada/info_types.exp: info types new_integer_type +Running ./gdb.ada/int_deref.exp ... +UNSUPPORTED: gdb.ada/int_deref.exp: compilation foo.adb +Running ./gdb.ada/interface.exp ... +UNSUPPORTED: gdb.ada/interface.exp: compilation foo.adb +Running ./gdb.ada/iwide.exp ... +UNSUPPORTED: gdb.ada/iwide.exp: compilation p.adb +Running ./gdb.ada/lang_switch.exp ... +UNSUPPORTED: gdb.ada/lang_switch.exp: compilation lang_switch.adb +Running ./gdb.ada/mi_catch_ex.exp ... +UNSUPPORTED: gdb.ada/mi_catch_ex.exp: compilation foo.adb +Running ./gdb.ada/mi_task_arg.exp ... +UNSUPPORTED: gdb.ada/mi_task_arg.exp: compilation task_switch.adb +Running ./gdb.ada/mi_task_info.exp ... +UNSUPPORTED: gdb.ada/mi_task_info.exp: compilation task_switch.adb +Running ./gdb.ada/mod_from_name.exp ... +UNSUPPORTED: gdb.ada/mod_from_name.exp: compilation foo.adb +Running ./gdb.ada/nested.exp ... +UNSUPPORTED: gdb.ada/nested.exp: compilation hello.adb +Running ./gdb.ada/null_array.exp ... +UNSUPPORTED: gdb.ada/null_array.exp: compilation foo.adb +Running ./gdb.ada/null_record.exp ... +UNSUPPORTED: gdb.ada/null_record.exp: compilation null_record.adb +Running ./gdb.ada/operator_bp.exp ... +UNSUPPORTED: gdb.ada/operator_bp.exp: compilation ops_test.adb +Running ./gdb.ada/optim_drec.exp ... +UNSUPPORTED: gdb.ada/optim_drec.exp: compilation foo.adb +Running ./gdb.ada/packed_array.exp ... +UNSUPPORTED: gdb.ada/packed_array.exp: compilation pa.adb +Running ./gdb.ada/packed_tagged.exp ... +UNSUPPORTED: gdb.ada/packed_tagged.exp: compilation comp_bug.adb +Running ./gdb.ada/print_chars.exp ... +UNSUPPORTED: gdb.ada/print_chars.exp: compilation foo.adb +Running ./gdb.ada/print_pc.exp ... +UNSUPPORTED: gdb.ada/print_pc.exp: compilation dummy.adb +Running ./gdb.ada/ptr_typedef.exp ... +UNSUPPORTED: gdb.ada/ptr_typedef.exp: compilation foo.adb +Running ./gdb.ada/ptype_arith_binop.exp ... +PASS: gdb.ada/ptype_arith_binop.exp: set lang ada +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 * 2.0 +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 / 2.0 +Running ./gdb.ada/ptype_field.exp ... +UNSUPPORTED: gdb.ada/ptype_field.exp: compilation foo.adb +Running ./gdb.ada/ptype_tagged_param.exp ... +UNSUPPORTED: gdb.ada/ptype_tagged_param.exp: compilation foo.adb +Running ./gdb.ada/rdv_wait.exp ... +UNSUPPORTED: gdb.ada/rdv_wait.exp: compilation foo.adb +Running ./gdb.ada/rec_return.exp ... +UNSUPPORTED: gdb.ada/rec_return.exp: compilation foo.adb +Running ./gdb.ada/ref_param.exp ... +UNSUPPORTED: gdb.ada/ref_param.exp: compilation foo.adb +Running ./gdb.ada/ref_tick_size.exp ... +UNSUPPORTED: gdb.ada/ref_tick_size.exp: compilation p.adb +Running ./gdb.ada/same_enum.exp ... +UNSUPPORTED: gdb.ada/same_enum.exp: compilation a.adb +Running ./gdb.ada/set_pckd_arr_elt.exp ... +UNSUPPORTED: gdb.ada/set_pckd_arr_elt.exp: compilation foo.adb +Running ./gdb.ada/set_wstr.exp ... +UNSUPPORTED: gdb.ada/set_wstr.exp: compilation a.adb +Running ./gdb.ada/small_reg_param.exp ... +UNSUPPORTED: gdb.ada/small_reg_param.exp: compilation foo.adb +Running ./gdb.ada/start.exp ... +UNTESTED: gdb.ada/start.exp: start.exp +Running ./gdb.ada/str_ref_cmp.exp ... +UNSUPPORTED: gdb.ada/str_ref_cmp.exp: compilation foo.adb +Running ./gdb.ada/sym_print_name.exp ... +UNSUPPORTED: gdb.ada/sym_print_name.exp: compilation foo.adb +Running ./gdb.ada/taft_type.exp ... +UNSUPPORTED: gdb.ada/taft_type.exp: compilation p.adb +Running ./gdb.ada/tagged.exp ... +UNSUPPORTED: gdb.ada/tagged.exp: compilation foo.adb +Running ./gdb.ada/tagged_not_init.exp ... +UNSUPPORTED: gdb.ada/tagged_not_init.exp: compilation foo.adb +Running ./gdb.ada/task_bp.exp ... +UNSUPPORTED: gdb.ada/task_bp.exp: compilation foo.adb +Running ./gdb.ada/tasks.exp ... +UNSUPPORTED: gdb.ada/tasks.exp: compilation foo.adb +Running ./gdb.ada/tick_last_segv.exp ... +UNSUPPORTED: gdb.ada/tick_last_segv.exp: compilation foo.adb +Running ./gdb.ada/type_coercion.exp ... +UNSUPPORTED: gdb.ada/type_coercion.exp: compilation assign.adb +Running ./gdb.ada/unc_arr_ptr_in_var_rec.exp ... +UNSUPPORTED: gdb.ada/unc_arr_ptr_in_var_rec.exp: compilation foo.adb +Running ./gdb.ada/uninitialized_vars.exp ... +UNSUPPORTED: gdb.ada/uninitialized_vars.exp: compilation parse.adb +Running ./gdb.ada/variant_record_packed_array.exp ... +UNSUPPORTED: gdb.ada/variant_record_packed_array.exp: compilation foo.adb +Running ./gdb.ada/watch_arg.exp ... +UNSUPPORTED: gdb.ada/watch_arg.exp: compilation watch.adb +Running ./gdb.ada/whatis_array_val.exp ... +UNSUPPORTED: gdb.ada/whatis_array_val.exp: compilation foo.adb +Running ./gdb.ada/widewide.exp ... +UNSUPPORTED: gdb.ada/widewide.exp: compilation foo.adb +Running ./gdb.arch/alpha-step.exp ... +Running ./gdb.arch/altivec-abi.exp ... +Running ./gdb.arch/altivec-regs.exp ... +Running ./gdb.arch/amd64-byte.exp ... +Running ./gdb.arch/amd64-disp-step.exp ... +Running ./gdb.arch/amd64-dword.exp ... +Running ./gdb.arch/amd64-entry-value.exp ... +Running ./gdb.arch/amd64-entry-value-inline.exp ... +Running ./gdb.arch/amd64-entry-value-param.exp ... +Running ./gdb.arch/amd64-i386-address.exp ... +Running ./gdb.arch/amd64-prologue-xmm.exp ... +Running ./gdb.arch/amd64-tailcall-cxx.exp ... +Running ./gdb.arch/amd64-tailcall-noret.exp ... +Running ./gdb.arch/amd64-tailcall-ret.exp ... +Running ./gdb.arch/amd64-word.exp ... +Running ./gdb.arch/arm-bl-branch-dest.exp ... +Running ./gdb.arch/arm-disp-step.exp ... +Running ./gdb.arch/e500-abi.exp ... +Running ./gdb.arch/e500-prologue.exp ... +Running ./gdb.arch/e500-regs.exp ... +Running ./gdb.arch/gdb1291.exp ... +Running ./gdb.arch/gdb1431.exp ... +Running ./gdb.arch/gdb1558.exp ... +Running ./gdb.arch/i386-avx.exp ... +Running ./gdb.arch/i386-bp_permanent.exp ... +PASS: gdb.arch/i386-bp_permanent.exp: Stop at the 'standard' start breakpoint (fetching esp). +PASS: gdb.arch/i386-bp_permanent.exp: Stop at permanent breakpoint. +PASS: gdb.arch/i386-bp_permanent.exp: Single stepping past permanent breakpoint. +PASS: gdb.arch/i386-bp_permanent.exp: ESP value does not match - step_permanent_breakpoint wrong. +Running ./gdb.arch/i386-byte.exp ... +gdb compile failed, ./gdb.arch/i386-pseudo.c: In function 'main': +./gdb.arch/i386-pseudo.c:32:3: error: PIC register clobbered by 'ebx' in 'asm' + asm ("mov 0(%0), %%eax\n\t" + ^ +./gdb.arch/i386-pseudo.c:41:3: error: PIC register clobbered by 'ebx' in 'asm' + asm ("mov %%eax, 0(%0)\n\t" + ^ +UNTESTED: gdb.arch/i386-byte.exp: i386-byte +Running ./gdb.arch/i386-cfi-notcurrent.exp ... +PASS: gdb.arch/i386-cfi-notcurrent.exp: backtrace +Running ./gdb.arch/i386-disp-step.exp ... +PASS: gdb.arch/i386-disp-step.exp: set displaced-stepping on +PASS: gdb.arch/i386-disp-step.exp: show displaced-stepping +PASS: gdb.arch/i386-disp-step.exp: break test_call +PASS: gdb.arch/i386-disp-step.exp: break test_call_end +PASS: gdb.arch/i386-disp-step.exp: break test_ret +PASS: gdb.arch/i386-disp-step.exp: break test_ret_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_call +PASS: gdb.arch/i386-disp-step.exp: continue to test_call_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_ret +PASS: gdb.arch/i386-disp-step.exp: continue to test_ret_end +PASS: gdb.arch/i386-disp-step.exp: break test_prefixed_abs_jump +PASS: gdb.arch/i386-disp-step.exp: break test_prefixed_abs_jump_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_prefixed_abs_jump +PASS: gdb.arch/i386-disp-step.exp: continue to test_prefixed_abs_jump_end +PASS: gdb.arch/i386-disp-step.exp: break test_syscall +PASS: gdb.arch/i386-disp-step.exp: break test_syscall_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_syscall +PASS: gdb.arch/i386-disp-step.exp: continue to test_syscall_end +PASS: gdb.arch/i386-disp-step.exp: break test_prefixed_syscall +PASS: gdb.arch/i386-disp-step.exp: break test_prefixed_syscall_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_prefixed_syscall +PASS: gdb.arch/i386-disp-step.exp: continue to test_prefixed_syscall_end +PASS: gdb.arch/i386-disp-step.exp: break test_int3 +PASS: gdb.arch/i386-disp-step.exp: break test_int3_end +PASS: gdb.arch/i386-disp-step.exp: continue to test_int3 +PASS: gdb.arch/i386-disp-step.exp: continue to test_int3_end +PASS: gdb.arch/i386-disp-step.exp: continue until exit at i386-disp-step +Running ./gdb.arch/i386-dr3-watch.exp ... +PASS: gdb.arch/i386-dr3-watch.exp: set breakpoint always-inserted on +PASS: gdb.arch/i386-dr3-watch.exp: watch i1 +PASS: gdb.arch/i386-dr3-watch.exp: watch i2 +PASS: gdb.arch/i386-dr3-watch.exp: watch i3 +PASS: gdb.arch/i386-dr3-watch.exp: watch i4 +PASS: gdb.arch/i386-dr3-watch.exp: continue to i1 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i2 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i3 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i4 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: set watchpoint occuping one debug register +PASS: gdb.arch/i386-dr3-watch.exp: watchpoint on gap1 does not fit debug registers +PASS: gdb.arch/i386-dr3-watch.exp: delete all watchpoints +PASS: gdb.arch/i386-dr3-watch.exp: watch i1 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i2 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i3 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i4 still fits +Running ./gdb.arch/i386-float.exp ... +PASS: gdb.arch/i386-float.exp: first stepi +PASS: gdb.arch/i386-float.exp: info float +PASS: gdb.arch/i386-float.exp: second stepi +PASS: gdb.arch/i386-float.exp: info float +Running ./gdb.arch/i386-gnu-cfi.exp ... +PASS: gdb.arch/i386-gnu-cfi.exp: continue to abort() +PASS: gdb.arch/i386-gnu-cfi.exp: backtrace +PASS: gdb.arch/i386-gnu-cfi.exp: shift up to the modified frame +PASS: gdb.arch/i386-gnu-cfi.exp: Existence of the CFI inserted register +PASS: gdb.arch/i386-gnu-cfi.exp: Value of the CFI inserted register +Running ./gdb.arch/i386-permbkpt.exp ... +PASS: gdb.arch/i386-permbkpt.exp: First permanent break +PASS: gdb.arch/i386-permbkpt.exp: Second permanent break +Running ./gdb.arch/i386-prologue.exp ... +PASS: gdb.arch/i386-prologue.exp: continue to standard +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in standard +PASS: gdb.arch/i386-prologue.exp: backtrace in standard +PASS: gdb.arch/i386-prologue.exp: saved registers in standard +PASS: gdb.arch/i386-prologue.exp: break *(stack_align_ecx + 7) +PASS: gdb.arch/i386-prologue.exp: continue to stack_align_ecx + 7 +PASS: gdb.arch/i386-prologue.exp: first backtrace in stack_align_ecx +PASS: gdb.arch/i386-prologue.exp: continue in stack_align_ecx +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in stack_align_ecx +PASS: gdb.arch/i386-prologue.exp: second backtrace in stack_align_ecx +PASS: gdb.arch/i386-prologue.exp: saved registers in stack_align_ecx +PASS: gdb.arch/i386-prologue.exp: break *(stack_align_edx + 7) +PASS: gdb.arch/i386-prologue.exp: continue to stack_align_edx + 7 +PASS: gdb.arch/i386-prologue.exp: first backtrace in stack_align_edx +PASS: gdb.arch/i386-prologue.exp: continue in stack_align_edx +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in stack_align_edx +PASS: gdb.arch/i386-prologue.exp: second backtrace in stack_align_edx +PASS: gdb.arch/i386-prologue.exp: saved registers in stack_align_edx +PASS: gdb.arch/i386-prologue.exp: break *(stack_align_eax + 7) +PASS: gdb.arch/i386-prologue.exp: continue to stack_align_eax + 7 +PASS: gdb.arch/i386-prologue.exp: first backtrace in stack_align_eax +PASS: gdb.arch/i386-prologue.exp: continue in stack_align_eax +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in stack_align_eax +PASS: gdb.arch/i386-prologue.exp: second backtrace in stack_align_eax +PASS: gdb.arch/i386-prologue.exp: saved registers in stack_align_eax +PASS: gdb.arch/i386-prologue.exp: continue to gdb1253 +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in gdb1253 +PASS: gdb.arch/i386-prologue.exp: backtrace in gdb1253 +PASS: gdb.arch/i386-prologue.exp: saved registers in gdb1253 +PASS: gdb.arch/i386-prologue.exp: continue to gdb1718 +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in gdb1718 +PASS: gdb.arch/i386-prologue.exp: backtrace in gdb1718 +KFAIL: gdb.arch/i386-prologue.exp: saved registers in gdb1718 (PRMS: gdb/1718) +PASS: gdb.arch/i386-prologue.exp: continue to gdb1338 +PASS: gdb.arch/i386-prologue.exp: skip breakpoint in gdb1338 +PASS: gdb.arch/i386-prologue.exp: backtrace in gdb1338 +PASS: gdb.arch/i386-prologue.exp: saved registers in gdb1338 +PASS: gdb.arch/i386-prologue.exp: check jump_at_beginning prologue end +Running ./gdb.arch/i386-signal.exp ... +PASS: gdb.arch/i386-signal.exp: backtrace 10 +PASS: gdb.arch/i386-signal.exp: finish +Running ./gdb.arch/i386-size.exp ... +PASS: gdb.arch/i386-size.exp: run past main +PASS: gdb.arch/i386-size.exp: backtrace shows no function +PASS: gdb.arch/i386-size.exp: disassemble stops at end of main +Running ./gdb.arch/i386-size-overlap.exp ... +PASS: gdb.arch/i386-size-overlap.exp: run past main +PASS: gdb.arch/i386-size-overlap.exp: backtrace shows the outer function +Running ./gdb.arch/i386-sse.exp ... +PASS: gdb.arch/i386-sse.exp: check whether processor supports SSE +PASS: gdb.arch/i386-sse.exp: set first breakpoint in main +PASS: gdb.arch/i386-sse.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm0 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm0 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm1 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm1 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm2 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm2 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm3 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm3 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm4 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm4 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm5 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm5 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm6 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm6 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm7 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm7 +PASS: gdb.arch/i386-sse.exp: set %xmm0 +PASS: gdb.arch/i386-sse.exp: set %xmm1 +PASS: gdb.arch/i386-sse.exp: set %xmm2 +PASS: gdb.arch/i386-sse.exp: set %xmm3 +PASS: gdb.arch/i386-sse.exp: set %xmm4 +PASS: gdb.arch/i386-sse.exp: set %xmm5 +PASS: gdb.arch/i386-sse.exp: set %xmm6 +PASS: gdb.arch/i386-sse.exp: set %xmm7 +PASS: gdb.arch/i386-sse.exp: set second breakpoint in main +PASS: gdb.arch/i386-sse.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/i386-sse.exp: check contents of data[0] +PASS: gdb.arch/i386-sse.exp: check contents of data[1] +PASS: gdb.arch/i386-sse.exp: check contents of data[2] +PASS: gdb.arch/i386-sse.exp: check contents of data[3] +PASS: gdb.arch/i386-sse.exp: check contents of data[4] +PASS: gdb.arch/i386-sse.exp: check contents of data[5] +PASS: gdb.arch/i386-sse.exp: check contents of data[6] +PASS: gdb.arch/i386-sse.exp: check contents of data[7] +Running ./gdb.arch/i386-sse-stack-align.exp ... +PASS: gdb.arch/i386-sse-stack-align.exp: print g0 () +PASS: gdb.arch/i386-sse-stack-align.exp: print g1 (1) +PASS: gdb.arch/i386-sse-stack-align.exp: print g2 (1, 2) +PASS: gdb.arch/i386-sse-stack-align.exp: print g3 (1, 2, 3) +PASS: gdb.arch/i386-sse-stack-align.exp: print g4 (1, 2, 3, 4) +Running ./gdb.arch/i386-unwind.exp ... +PASS: gdb.arch/i386-unwind.exp: run past gdb1435 +PASS: gdb.arch/i386-unwind.exp: backtrace past gdb1435 +Running ./gdb.arch/i386-word.exp ... +gdb compile failed, ./gdb.arch/i386-pseudo.c: In function 'main': +./gdb.arch/i386-pseudo.c:32:3: error: PIC register clobbered by 'ebx' in 'asm' + asm ("mov 0(%0), %%eax\n\t" + ^ +./gdb.arch/i386-pseudo.c:41:3: error: PIC register clobbered by 'ebx' in 'asm' + asm ("mov %%eax, 0(%0)\n\t" + ^ +UNTESTED: gdb.arch/i386-word.exp: i386-word +Running ./gdb.arch/ia64-breakpoint-shadow.exp ... +Running ./gdb.arch/iwmmxt-regs.exp ... +Running ./gdb.arch/mips16-thunks.exp ... +Running ./gdb.arch/mips-octeon-bbit.exp ... +Running ./gdb.arch/pa-nullify.exp ... +Running ./gdb.arch/powerpc-aix-prologue.exp ... +Running ./gdb.arch/powerpc-d128-regs.exp ... +Running ./gdb.arch/powerpc-prologue.exp ... +Running ./gdb.arch/ppc64-atomic-inst.exp ... +Running ./gdb.arch/ppc-dfp.exp ... +Running ./gdb.arch/ppc-fp.exp ... +Running ./gdb.arch/spu-info.exp ... +Running ./gdb.arch/spu-ls.exp ... +Running ./gdb.arch/system-gcore.exp ... +PASS: gdb.arch/system-gcore.exp: help gcore +PASS: gdb.arch/system-gcore.exp: set breakpoint at terminal_func +PASS: gdb.arch/system-gcore.exp: continue to terminal_func +PASS: gdb.arch/system-gcore.exp: save a corefile +FAIL: gdb.arch/system-gcore.exp: re-load generated corefile (bad file format) +Running ./gdb.arch/thumb2-it.exp ... +Running ./gdb.arch/thumb-bx-pc.exp ... +Running ./gdb.arch/thumb-prologue.exp ... +Running ./gdb.arch/thumb-singlestep.exp ... +Running ./gdb.arch/vsx-regs.exp ... +Running ./gdb.asm/asm-source.exp ... +PASS: gdb.asm/asm-source.exp: f at main +PASS: gdb.asm/asm-source.exp: next over macro +PASS: gdb.asm/asm-source.exp: step into foo2 +PASS: gdb.asm/asm-source.exp: info target +PASS: gdb.asm/asm-source.exp: info symbol +PASS: gdb.asm/asm-source.exp: list +PASS: gdb.asm/asm-source.exp: search +PASS: gdb.asm/asm-source.exp: f in foo2 +PASS: gdb.asm/asm-source.exp: n in foo2 +PASS: gdb.asm/asm-source.exp: bt ALL in foo2 +PASS: gdb.asm/asm-source.exp: bt 2 in foo2 +PASS: gdb.asm/asm-source.exp: s 2 +PASS: gdb.asm/asm-source.exp: n 2 +PASS: gdb.asm/asm-source.exp: bt 3 in foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc1.s +PASS: gdb.asm/asm-source.exp: finish from foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc2.s +PASS: gdb.asm/asm-source.exp: info sources +PASS: gdb.asm/asm-source.exp: info line +PASS: gdb.asm/asm-source.exp: next over foo3 +PASS: gdb.asm/asm-source.exp: return from foo2 +PASS: gdb.asm/asm-source.exp: look at global variable +PASS: gdb.asm/asm-source.exp: x/i &globalvar +PASS: gdb.asm/asm-source.exp: disassem &globalvar, &globalvar+1 +PASS: gdb.asm/asm-source.exp: look at static variable +PASS: gdb.asm/asm-source.exp: x/i &staticvar +PASS: gdb.asm/asm-source.exp: disassem &staticvar, &staticvar+1 +PASS: gdb.asm/asm-source.exp: look at static function +Running ./gdb.base/a2-run.exp ... +Running ./gdb.base/advance.exp ... +PASS: gdb.base/advance.exp: advance line number +PASS: gdb.base/advance.exp: malformed advance +PASS: gdb.base/advance.exp: advance func +PASS: gdb.base/advance.exp: advance function not called by current frame +PASS: gdb.base/advance.exp: set breakpoint at call to func3 +PASS: gdb.base/advance.exp: continue to call to func3 in main +PASS: gdb.base/advance.exp: advance function called as param +PASS: gdb.base/advance.exp: advance with no argument +Running ./gdb.base/alias.exp ... +PASS: gdb.base/alias.exp: alias -a set2=set +PASS: gdb.base/alias.exp: set2 print elements 42 +PASS: gdb.base/alias.exp: verify set2 +PASS: gdb.base/alias.exp: abbrev set2 not present in help command list +PASS: gdb.base/alias.exp: alias -a set3= set +PASS: gdb.base/alias.exp: set3 print elements 43 +PASS: gdb.base/alias.exp: verify set3 +PASS: gdb.base/alias.exp: abbrev set3 not present in help command list +PASS: gdb.base/alias.exp: alias -a set4 =set +PASS: gdb.base/alias.exp: set4 print elements 44 +PASS: gdb.base/alias.exp: verify set4 +PASS: gdb.base/alias.exp: abbrev set4 not present in help command list +PASS: gdb.base/alias.exp: alias -a set5 = set +PASS: gdb.base/alias.exp: set5 print elements 45 +PASS: gdb.base/alias.exp: verify set5 +PASS: gdb.base/alias.exp: abbrev set5 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- set6 = set +PASS: gdb.base/alias.exp: set6 print elements 46 +PASS: gdb.base/alias.exp: verify set6 +PASS: gdb.base/alias.exp: abbrev set6 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- -a = set +PASS: gdb.base/alias.exp: -a print elements 47 +PASS: gdb.base/alias.exp: verify -a +PASS: gdb.base/alias.exp: abbrev -a not present in help command list +PASS: gdb.base/alias.exp: alias set2=set +PASS: gdb.base/alias.exp: alias foo=bar +PASS: gdb.base/alias.exp: alias spe = set p elem +PASS: gdb.base/alias.exp: spe 50 +PASS: gdb.base/alias.exp: verify spe +PASS: gdb.base/alias.exp: alias set pr elms = set p elem +PASS: gdb.base/alias.exp: set pr elms 51 +PASS: gdb.base/alias.exp: verify set pr elms +PASS: gdb.base/alias.exp: help set print +Running ./gdb.base/all-bin.exp ... +PASS: gdb.base/all-bin.exp: continuing after dummy() +PASS: gdb.base/all-bin.exp: print value of v_int+v_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_float +PASS: gdb.base/all-bin.exp: print value of v_int+v_double +PASS: gdb.base/all-bin.exp: print value of v_int<=v_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_float +PASS: gdb.base/all-bin.exp: print value of v_int<=v_double +PASS: gdb.base/all-bin.exp: set v_char=0 +PASS: gdb.base/all-bin.exp: set v_double=0 +PASS: gdb.base/all-bin.exp: set v_unsigned_long=0 +PASS: gdb.base/all-bin.exp: print value of v_int&&v_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_float +PASS: gdb.base/all-bin.exp: print value of v_int&&v_double +Running ./gdb.base/annota1.exp ... +Running ./gdb.base/annota3.exp ... +Running ./gdb.base/anon.exp ... +PASS: gdb.base/anon.exp: set breakpoint in anon.c +PASS: gdb.base/anon.exp: continue to breakpoint: continue to breakpoint in anon.c +PASS: gdb.base/anon.exp: print val.data.six +Running ./gdb.base/args.exp ... +Running ./gdb.base/argv0-symlink.exp ... +PASS: gdb.base/argv0-symlink.exp: kept file symbolic link name +FAIL: gdb.base/argv0-symlink.exp: kept directory symbolic link name +Running ./gdb.base/arithmet.exp ... +PASS: gdb.base/arithmet.exp: set variable x=14 +PASS: gdb.base/arithmet.exp: set variable y=2 +PASS: gdb.base/arithmet.exp: set variable z=2 +PASS: gdb.base/arithmet.exp: set variable w=3 +PASS: gdb.base/arithmet.exp: print x +PASS: gdb.base/arithmet.exp: print y +PASS: gdb.base/arithmet.exp: print z +PASS: gdb.base/arithmet.exp: print w +PASS: gdb.base/arithmet.exp: print x+y +PASS: gdb.base/arithmet.exp: print x-y +PASS: gdb.base/arithmet.exp: print x*y +PASS: gdb.base/arithmet.exp: print x/y +PASS: gdb.base/arithmet.exp: print x%y +PASS: gdb.base/arithmet.exp: print x+y+z +PASS: gdb.base/arithmet.exp: print x-y-z +PASS: gdb.base/arithmet.exp: print x*y*z +PASS: gdb.base/arithmet.exp: print x/y/z +PASS: gdb.base/arithmet.exp: print x%y%z +PASS: gdb.base/arithmet.exp: set variable x=10 +PASS: gdb.base/arithmet.exp: set variable y=4 +PASS: gdb.base/arithmet.exp: print x+y-z +PASS: gdb.base/arithmet.exp: print x+y*z +PASS: gdb.base/arithmet.exp: print x+y%w +PASS: gdb.base/arithmet.exp: print x+y/w +PASS: gdb.base/arithmet.exp: print x-y*z +PASS: gdb.base/arithmet.exp: print x-y%z +PASS: gdb.base/arithmet.exp: print x-y/z +PASS: gdb.base/arithmet.exp: print x*y/z +PASS: gdb.base/arithmet.exp: print x*y%w +PASS: gdb.base/arithmet.exp: print x/y%w +PASS: gdb.base/arithmet.exp: print x-(y+w) +PASS: gdb.base/arithmet.exp: print x/(y*w) +PASS: gdb.base/arithmet.exp: print x-(y/w) +PASS: gdb.base/arithmet.exp: print (x+y)*w +Running ./gdb.base/arrayidx.exp ... +PASS: gdb.base/arrayidx.exp: Set print array-indexes to off +PASS: gdb.base/arrayidx.exp: Print array with array-indexes off +PASS: gdb.base/arrayidx.exp: Set print array-indexes to on +PASS: gdb.base/arrayidx.exp: Print array with array-indexes on +Running ./gdb.base/assign.exp ... +PASS: gdb.base/assign.exp: continuing after dummy() +PASS: gdb.base/assign.exp: v_int=57 +PASS: gdb.base/assign.exp: set v_int to 6 +PASS: gdb.base/assign.exp: v_int+=57 +PASS: gdb.base/assign.exp: set v_int to 6 (2) +PASS: gdb.base/assign.exp: v_int-=57 +PASS: gdb.base/assign.exp: set v_int to 6 (3) +PASS: gdb.base/assign.exp: v_int*=5 +PASS: gdb.base/assign.exp: set v_int to 6 (4) +PASS: gdb.base/assign.exp: v_int/=4 +PASS: gdb.base/assign.exp: set v_int to 6 (5) +PASS: gdb.base/assign.exp: v_int%=4 +PASS: gdb.base/assign.exp: set v_int to 6 (6) +PASS: gdb.base/assign.exp: v_int+=char +PASS: gdb.base/assign.exp: set v_int to 6 (7) +PASS: gdb.base/assign.exp: v_int+=signed_char +PASS: gdb.base/assign.exp: set v_int to 6 (8) +PASS: gdb.base/assign.exp: v_int+=unsigned_char +PASS: gdb.base/assign.exp: set v_int to 6 (9) +PASS: gdb.base/assign.exp: v_int+=short +PASS: gdb.base/assign.exp: set v_int to 6 (10) +PASS: gdb.base/assign.exp: v_int+=signed_short +PASS: gdb.base/assign.exp: set v_int to 6 (11) +PASS: gdb.base/assign.exp: v_int=+unsigned_short +PASS: gdb.base/assign.exp: set v_int to 6 (12) +PASS: gdb.base/assign.exp: v_int+=signed_int +PASS: gdb.base/assign.exp: set v_int to 6 (13) +PASS: gdb.base/assign.exp: v_int+=unsigned_int +PASS: gdb.base/assign.exp: set v_int to 6 (14) +PASS: gdb.base/assign.exp: v_int+=long +PASS: gdb.base/assign.exp: set v_int to 6 (15) +PASS: gdb.base/assign.exp: v_int+=signed_long +PASS: gdb.base/assign.exp: set v_int to 6 (16) +PASS: gdb.base/assign.exp: v_int+=unsigned_long +PASS: gdb.base/assign.exp: set v_int to 6 (17) +PASS: gdb.base/assign.exp: v_int+=v_float +PASS: gdb.base/assign.exp: set v_int to 6 (18) +PASS: gdb.base/assign.exp: v_int+=double +Running ./gdb.base/async.exp ... +Running ./gdb.base/async-shell.exp ... +Running ./gdb.base/attach.exp ... +Running ./gdb.base/attach-pie-misread.exp ... +Running ./gdb.base/attach-pie-noexec.exp ... +Running ./gdb.base/attach-twice.exp ... +Running ./gdb.base/auxv.exp ... +PASS: gdb.base/auxv.exp: set print sevenbit-strings +PASS: gdb.base/auxv.exp: set width 0 +PASS: gdb.base/auxv.exp: tbreak 78 +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: info auxv on live process +PASS: gdb.base/auxv.exp: gcore +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: continue +UNSUPPORTED: gdb.base/auxv.exp: generate native core dump +UNSUPPORTED: gdb.base/auxv.exp: info auxv on native core dump +UNSUPPORTED: gdb.base/auxv.exp: matching auxv data from live and core +FAIL: gdb.base/auxv.exp: load core file for info auxv on gcore-created dump +FAIL: gdb.base/auxv.exp: info auxv on gcore-created dump +FAIL: gdb.base/auxv.exp: matching auxv data from live and gcore +Running ./gdb.base/bang.exp ... +PASS: gdb.base/bang.exp: run program +Running ./gdb.base/bfp-test.exp ... +PASS: gdb.base/bfp-test.exp: continue to breakpoint: return +PASS: gdb.base/bfp-test.exp: The original value of b32 is 1.5 +PASS: gdb.base/bfp-test.exp: The original value of b64 is 2.25 +PASS: gdb.base/bfp-test.exp: The original value of b128 is 3.375 +PASS: gdb.base/bfp-test.exp: Try to change b32 to -1.5 with 'print b32=-1.5f' +PASS: gdb.base/bfp-test.exp: Try to change b64 to -2.25 with 'print b64=-2.25f' +PASS: gdb.base/bfp-test.exp: Try to change b128 to -3.375 with 'print b128=-3.375l' +PASS: gdb.base/bfp-test.exp: set variable b32 = 10.5f +PASS: gdb.base/bfp-test.exp: set variable b64 = 20.25f +PASS: gdb.base/bfp-test.exp: set variable b128 = 30.375l +PASS: gdb.base/bfp-test.exp: The value of b32 is changed to 10.5 +PASS: gdb.base/bfp-test.exp: The value of b64 is changed to 20.25 +PASS: gdb.base/bfp-test.exp: The value of b128 is changed to 30.375 +PASS: gdb.base/bfp-test.exp: set variable b32 = 100.5a +PASS: gdb.base/bfp-test.exp: set variable b64 = 200.25x +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fl +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fff +Running ./gdb.base/bigcore.exp ... +UNTESTED: gdb.base/bigcore.exp: Remote system +Running ./gdb.base/bitfields2.exp ... +PASS: gdb.base/bitfields2.exp: set print sevenbit-strings +PASS: gdb.base/bitfields2.exp: break tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #0 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #1 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #2 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #3 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #4 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s3 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #5 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u3 = 1 +PASS: gdb.base/bitfields2.exp: break tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to break2 #0 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u1, flags.u3, and flags.s3 to all 1s +PASS: gdb.base/bitfields2.exp: continuing to break2 #1 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u2, flags.s1, flags.s2 to all 1s +PASS: gdb.base/bitfields2.exp: break tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to break3 #0 +PASS: gdb.base/bitfields2.exp: maximum unsigned bitfield values +PASS: gdb.base/bitfields2.exp: break tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to break4 #0 +PASS: gdb.base/bitfields2.exp: maximum signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #1 +PASS: gdb.base/bitfields2.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields2.exp: most negative signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #2 +PASS: gdb.base/bitfields2.exp: signed bitfields containing -1 +PASS: gdb.base/bitfields2.exp: break tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to break5 #0 +PASS: gdb.base/bitfields2.exp: set long long unsigned bitfield +PASS: gdb.base/bitfields2.exp: set long long signed bitfield positive +PASS: gdb.base/bitfields2.exp: long long bitfield values after set +PASS: gdb.base/bitfields2.exp: set long long signed bitfield negative +PASS: gdb.base/bitfields2.exp: long long bitfield values after set negative +Running ./gdb.base/bitfields.exp ... +PASS: gdb.base/bitfields.exp: set print sevenbit-strings +PASS: gdb.base/bitfields.exp: print flags +PASS: gdb.base/bitfields.exp: continuing to break1 #1 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s1) +PASS: gdb.base/bitfields.exp: continuing to break1 #2 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u1) +PASS: gdb.base/bitfields.exp: continuing to break1 #3 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s2) +PASS: gdb.base/bitfields.exp: continuing to break1 #4 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u2) +PASS: gdb.base/bitfields.exp: continuing to break1 #5 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s3) +PASS: gdb.base/bitfields.exp: continuing to break1 #6 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u3) +PASS: gdb.base/bitfields.exp: continuing to break1 #7 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s9) +PASS: gdb.base/bitfields.exp: continuing to break1 #8 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u9) +PASS: gdb.base/bitfields.exp: continuing to break1 #9 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (sc) +PASS: gdb.base/bitfields.exp: bitfield containment #1 +PASS: gdb.base/bitfields.exp: continuing to break2 +PASS: gdb.base/bitfields.exp: bitfield containment #2 +PASS: gdb.base/bitfields.exp: unsigned bitfield ranges +PASS: gdb.base/bitfields.exp: signed bitfields, max positive values +PASS: gdb.base/bitfields.exp: continuing to break4 #1 +PASS: gdb.base/bitfields.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields.exp: signed bitfields, max negative values +PASS: gdb.base/bitfields.exp: continuing to break4 #2 +PASS: gdb.base/bitfields.exp: signed bitfields with -1 +PASS: gdb.base/bitfields.exp: continuing to break5 +PASS: gdb.base/bitfields.exp: distinct bitfields in container +PASS: gdb.base/bitfields.exp: print container.one.u3 +PASS: gdb.base/bitfields.exp: print container.two.u3 +PASS: gdb.base/bitfields.exp: set internal var +PASS: gdb.base/bitfields.exp: set $myvar.a = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.b = 1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.c = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.d = -1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.e = 1 +PASS: gdb.base/bitfields.exp: set $myvar.f = 1 +PASS: gdb.base/bitfields.exp: print $myvar.a +PASS: gdb.base/bitfields.exp: print $myvar.inner.b +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.c +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.d +PASS: gdb.base/bitfields.exp: print $myvar.inner.e +PASS: gdb.base/bitfields.exp: print $myvar.f +Running ./gdb.base/bitops.exp ... +PASS: gdb.base/bitops.exp: print value of !1 +PASS: gdb.base/bitops.exp: print value of !0 +PASS: gdb.base/bitops.exp: print value of !100 +PASS: gdb.base/bitops.exp: print value of !1000 +PASS: gdb.base/bitops.exp: print value of !10 +PASS: gdb.base/bitops.exp: print value of !2 +PASS: gdb.base/bitops.exp: print value of 10 | 5 +PASS: gdb.base/bitops.exp: print value of 10 & 5 +PASS: gdb.base/bitops.exp: print value of 10 ^ 5 +PASS: gdb.base/bitops.exp: print value of -!0 +PASS: gdb.base/bitops.exp: print value of ~-!0 +PASS: gdb.base/bitops.exp: print value of 3 * 2 / 4.0 * 2.0 +PASS: gdb.base/bitops.exp: print value of 8 << 2 >> 4 +PASS: gdb.base/bitops.exp: print value of -1 < 0 > 1 +PASS: gdb.base/bitops.exp: print value of 15 ^ 10 ^ 5 ^ 7 +PASS: gdb.base/bitops.exp: print value of 3.5 < 4.0 +PASS: gdb.base/bitops.exp: print value of 3.5 < -4.0 +PASS: gdb.base/bitops.exp: print value of 2 > -3 +PASS: gdb.base/bitops.exp: print value of -3>4 +PASS: gdb.base/bitops.exp: print value of (-3 > 4) +PASS: gdb.base/bitops.exp: print value of 3>=2.5 +PASS: gdb.base/bitops.exp: print value of 3>=4.5 +PASS: gdb.base/bitops.exp: print value of 3==3.0 +PASS: gdb.base/bitops.exp: print value of 3==4.0 +PASS: gdb.base/bitops.exp: print value of 3!=3.0 +PASS: gdb.base/bitops.exp: print value of 3!=5.0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 > 128 >>1 +2 *2 +PASS: gdb.base/bitops.exp: print value of 1.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 1.0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 +PASS: gdb.base/bitops.exp: print value of 0 == 8 > 128 >> 1 + 2 * 2 +Running ./gdb.base/break-always.exp ... +PASS: gdb.base/break-always.exp: set breakpoint always-inserted on +PASS: gdb.base/break-always.exp: confirm breakpoint always-inserted +PASS: gdb.base/break-always.exp: set breakpoint on bar +PASS: gdb.base/break-always.exp: set 2nd breakpoint on bar +PASS: gdb.base/break-always.exp: set 3rd breakpoint on bar +PASS: gdb.base/break-always.exp: set 4th breakpoint on bar +PASS: gdb.base/break-always.exp: initial check breakpoint state +PASS: gdb.base/break-always.exp: initial disable all breakpoints +PASS: gdb.base/break-always.exp: initial enable all breakpoints +PASS: gdb.base/break-always.exp: re-disable all breakpoints +PASS: gdb.base/break-always.exp: enable 3.A +PASS: gdb.base/break-always.exp: disable 3.B +PASS: gdb.base/break-always.exp: enable 3.C +PASS: gdb.base/break-always.exp: enable 2.D +PASS: gdb.base/break-always.exp: disable 2.E +PASS: gdb.base/break-always.exp: disable 3.F +PASS: gdb.base/break-always.exp: enable 3.G +PASS: gdb.base/break-always.exp: enable 2.H +PASS: gdb.base/break-always.exp: disable 2.I +PASS: gdb.base/break-always.exp: before re-enable check breakpoint state +PASS: gdb.base/break-always.exp: re-enable all breakpoints +PASS: gdb.base/break-always.exp: set breakpoint on bar 2 +PASS: gdb.base/break-always.exp: save shadow +PASS: gdb.base/break-always.exp: write 0 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 0 from the breakpoint's address +PASS: gdb.base/break-always.exp: write 1 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 1 from the breakpoint's address +PASS: gdb.base/break-always.exp: p /x *(char *) 0x555555c3 = $shadow +PASS: gdb.base/break-always.exp: continue to breakpoint: bar +Running ./gdb.base/break-caller-line.exp ... +PASS: gdb.base/break-caller-line.exp: up +PASS: gdb.base/break-caller-line.exp: info line *$pc +PASS: gdb.base/break-caller-line.exp: break +Running ./gdb.base/break-entry.exp ... +UNTESTED: gdb.base/break-entry.exp: break-entry.exp +Running ./gdb.base/break.exp ... +PASS: gdb.base/break.exp: Delete all breakpoints when none +PASS: gdb.base/break.exp: breakpoint function +PASS: gdb.base/break.exp: breakpoint quoted function +PASS: gdb.base/break.exp: breakpoint function in file +PASS: gdb.base/break.exp: use `list' to establish default source file +PASS: gdb.base/break.exp: breakpoint line number +PASS: gdb.base/break.exp: breakpoint duplicate +PASS: gdb.base/break.exp: breakpoint line number in file +PASS: gdb.base/break.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/break.exp: breakpoint at start of multi line while conditional +PASS: gdb.base/break.exp: breakpoint info +PASS: gdb.base/break.exp: info break 2 4 6 +PASS: gdb.base/break.exp: info break 3-5 +PASS: gdb.base/break.exp: disable using history values +PASS: gdb.base/break.exp: check disable with history values +PASS: gdb.base/break.exp: disable with convenience values +PASS: gdb.base/break.exp: check disable with convenience values +PASS: gdb.base/break.exp: disable non-existent breakpoint 10 +PASS: gdb.base/break.exp: set $baz 1.234 +PASS: gdb.base/break.exp: disable with non-integer convenience var +PASS: gdb.base/break.exp: disable with non-existent convenience var +PASS: gdb.base/break.exp: disable with non-existent history value +PASS: gdb.base/break.exp: disable with badly formed history value +PASS: gdb.base/break.exp: run until function breakpoint +PASS: gdb.base/break.exp: list marker1 +PASS: gdb.base/break.exp: break lineno +PASS: gdb.base/break.exp: delete $bpnum +PASS: gdb.base/break.exp: run until breakpoint set at a line number +PASS: gdb.base/break.exp: run until file:function(6) breakpoint +PASS: gdb.base/break.exp: run until file:function(5) breakpoint +PASS: gdb.base/break.exp: run until file:function(4) breakpoint +PASS: gdb.base/break.exp: run until file:function(3) breakpoint +PASS: gdb.base/break.exp: run until file:function(2) breakpoint +PASS: gdb.base/break.exp: run until file:function(1) breakpoint +PASS: gdb.base/break.exp: run until quoted breakpoint +PASS: gdb.base/break.exp: run until file:linenum breakpoint +PASS: gdb.base/break.exp: breakpoint offset +1 +PASS: gdb.base/break.exp: step onto breakpoint +PASS: gdb.base/break.exp: setting breakpoint at } +PASS: gdb.base/break.exp: continue to breakpoint at } +PASS: gdb.base/break.exp: Temporary breakpoint function +PASS: gdb.base/break.exp: Temporary breakpoint function in file +PASS: gdb.base/break.exp: Temporary breakpoint line number #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number #2 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #2 +PASS: gdb.base/break.exp: Temporary breakpoint info +PASS: gdb.base/break.exp: catch requires an event name +PASS: gdb.base/break.exp: set catch fork, never expected to trigger +PASS: gdb.base/break.exp: set catch vfork, never expected to trigger +PASS: gdb.base/break.exp: set catch exec, never expected to trigger +PASS: gdb.base/break.exp: set breakpoint pending off +PASS: gdb.base/break.exp: break on non-existent source line +PASS: gdb.base/break.exp: until bp_location1 +PASS: gdb.base/break.exp: break on default location, 1st time +PASS: gdb.base/break.exp: break on default location, 2nd time +PASS: gdb.base/break.exp: break on default location, 3rd time +PASS: gdb.base/break.exp: break on default location, 4th time +PASS: gdb.base/break.exp: set to-be-silent break bp_location1 +PASS: gdb.base/break.exp: set silent break bp_location1 +PASS: gdb.base/break.exp: info silent break bp_location1 +PASS: gdb.base/break.exp: hit silent break bp_location1 +PASS: gdb.base/break.exp: stopped for silent break bp_location1 +PASS: gdb.base/break.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/break.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/break.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/break.exp: step over breakpoint +PASS: gdb.base/break.exp: clear line has no breakpoint disallowed +PASS: gdb.base/break.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/break.exp: break marker3 #1 +PASS: gdb.base/break.exp: break marker3 #2 +PASS: gdb.base/break.exp: clear marker3 +PASS: gdb.base/break.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/break.exp: set breakpoint via convenience variable +PASS: gdb.base/break.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/break.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/break.exp: set breakpoint on to-be-called function +PASS: gdb.base/break.exp: hit breakpoint on called function +PASS: gdb.base/break.exp: backtrace while in called function +PASS: gdb.base/break.exp: finish from called function +PASS: gdb.base/break.exp: finish with arguments disallowed +PASS: gdb.base/break.exp: finish from outermost frame disallowed +PASS: gdb.base/break.exp: kill program +PASS: gdb.base/break.exp: break at factorial +PASS: gdb.base/break.exp: continue to factorial(5) +PASS: gdb.base/break.exp: backtrace from factorial(5) +PASS: gdb.base/break.exp: next to recursive call +PASS: gdb.base/break.exp: next over recursive call +PASS: gdb.base/break.exp: backtrace from factorial(5.1) +PASS: gdb.base/break.exp: continue until exit at recursive next test +PASS: gdb.base/break.exp: breakpoint function, optimized file +PASS: gdb.base/break.exp: breakpoint small function, optimized file +PASS: gdb.base/break.exp: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/break.exp: run until breakpoint set at small function, optimized file +PASS: gdb.base/break.exp: rbreak junk pending setup +PASS: gdb.base/break.exp: rbreak junk set breakpoint +PASS: gdb.base/break.exp: rbreak junk +Running ./gdb.base/break-inline.exp ... +PASS: gdb.base/break-inline.exp: break +Running ./gdb.base/break-interp.exp ... +Running ./gdb.base/break-on-linker-gcd-function.exp ... +PASS: gdb.base/break-on-linker-gcd-function.exp: b 25 +Running ./gdb.base/breakpoint-shadow.exp ... +PASS: gdb.base/breakpoint-shadow.exp: set breakpoint always-inserted on +PASS: gdb.base/breakpoint-shadow.exp: show breakpoint always-inserted +PASS: gdb.base/breakpoint-shadow.exp: disassembly without breakpoints +PASS: gdb.base/breakpoint-shadow.exp: First breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: Second breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: disassembly with breakpoints +Running ./gdb.base/call-ar-st.exp ... +PASS: gdb.base/call-ar-st.exp: set print sevenbit-strings +PASS: gdb.base/call-ar-st.exp: set print address off +PASS: gdb.base/call-ar-st.exp: set width 0 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1209 +PASS: gdb.base/call-ar-st.exp: run until breakpoint set at a line +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1216 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1220 +PASS: gdb.base/call-ar-st.exp: step inside print_all_arrays +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1236 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1241 +PASS: gdb.base/call-ar-st.exp: continue to 1241 +PASS: gdb.base/call-ar-st.exp: set breakpoint in sum_array_print +PASS: gdb.base/call-ar-st.exp: set print frame-arguments all +PASS: gdb.base/call-ar-st.exp: check args of sum_array_print +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1281 +PASS: gdb.base/call-ar-st.exp: print compute_with_small_structs(20) +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1286 +PASS: gdb.base/call-ar-st.exp: continue to 1286 +PASS: gdb.base/call-ar-st.exp: tbreak in print_long_arg_list after stepping into memcpy +PASS: gdb.base/call-ar-st.exp: step into print_long_arg_list +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1300 +PASS: gdb.base/call-ar-st.exp: step into init_bit_flags_combo +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1305 +PASS: gdb.base/call-ar-st.exp: continue to 1305 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1311 +PASS: gdb.base/call-ar-st.exp: continue to 1311 +Running ./gdb.base/callexit.exp ... +PASS: gdb.base/callexit.exp: inferior function call terminated program +Running ./gdb.base/callfuncs.exp ... +PASS: gdb.base/callfuncs.exp: set print sevenbit-strings +PASS: gdb.base/callfuncs.exp: set print address off +PASS: gdb.base/callfuncs.exp: set width 0 +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: set unwindonsignal on +PASS: gdb.base/callfuncs.exp: p t_char_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_char_values('a','b') +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values('a',char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,'b') +PASS: gdb.base/callfuncs.exp: p t_short_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,-23) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,-23) +PASS: gdb.base/callfuncs.exp: p t_int_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,-26) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,-26) +PASS: gdb.base/callfuncs.exp: p t_long_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,-321) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,-321) +PASS: gdb.base/callfuncs.exp: p t_float_values(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_float_values(3.14159,-2.3765) +PASS: gdb.base/callfuncs.exp: p t_float_values(float_val1,float_val2) +PASS: gdb.base/callfuncs.exp: p t_float_values(3.14159,float_val2) +PASS: gdb.base/callfuncs.exp: p t_float_values(float_val1,-2.3765) +PASS: gdb.base/callfuncs.exp: p t_float_values2(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_float_values2(3.14159,float_val2) +PASS: gdb.base/callfuncs.exp: Call function with many float arguments. +PASS: gdb.base/callfuncs.exp: p t_small_values(1,2,3,4,5,6,7,8,9,10) +PASS: gdb.base/callfuncs.exp: p t_double_values(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_double_values(45.654,-67.66) +PASS: gdb.base/callfuncs.exp: p t_double_values(double_val1,double_val2) +PASS: gdb.base/callfuncs.exp: p t_double_values(45.654,double_val2) +PASS: gdb.base/callfuncs.exp: p t_double_values(double_val1,-67.66) +PASS: gdb.base/callfuncs.exp: Call function with many double arguments. +PASS: gdb.base/callfuncs.exp: p t_double_int(99.0, 1) +PASS: gdb.base/callfuncs.exp: p t_double_int(99.0, 99) +PASS: gdb.base/callfuncs.exp: p t_int_double(99, 1.0) +PASS: gdb.base/callfuncs.exp: p t_int_double(99, 99.0) +PASS: gdb.base/callfuncs.exp: p t_float_complex_values(fc1, fc2) +PASS: gdb.base/callfuncs.exp: p t_float_complex_values(fc3, fc4) +PASS: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4) +PASS: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1) +PASS: gdb.base/callfuncs.exp: p t_double_complex_values(dc1, dc2) +PASS: gdb.base/callfuncs.exp: p t_double_complex_values(dc3, dc4) +PASS: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4) +PASS: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc1, ldc2) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc3, ldc4) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1,ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val2,string_val1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val1,string_val2) +PASS: gdb.base/callfuncs.exp: p t_string_values("string 1","string 2") +PASS: gdb.base/callfuncs.exp: p t_string_values("string 1",string_val2) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val1,"string 2") +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val2,char_array_val1) +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,char_array_val2) +PASS: gdb.base/callfuncs.exp: p t_char_array_values("carray 1","carray 2") +PASS: gdb.base/callfuncs.exp: p t_char_array_values("carray 1",char_array_val2) +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,"carray 2") +PASS: gdb.base/callfuncs.exp: p doubleit(4) +PASS: gdb.base/callfuncs.exp: p add(4,5) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val2,func_val1) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,func_val2) +PASS: gdb.base/callfuncs.exp: p function_struct.func(5) +PASS: gdb.base/callfuncs.exp: p function_struct_ptr->func(10) +PASS: gdb.base/callfuncs.exp: p t_func_values(add,func_val2) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,doubleit) +PASS: gdb.base/callfuncs.exp: p t_call_add(add,3,4) +PASS: gdb.base/callfuncs.exp: p t_call_add(func_val1,3,4) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enumval1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enumval2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val1) +PASS: gdb.base/callfuncs.exp: p sum_args(1,{2}) +PASS: gdb.base/callfuncs.exp: p sum_args(2,{2,3}) +PASS: gdb.base/callfuncs.exp: p sum_args(3,{2,3,4}) +PASS: gdb.base/callfuncs.exp: p sum_args(4,{2,3,4,5}) +PASS: gdb.base/callfuncs.exp: p sum10 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) +PASS: gdb.base/callfuncs.exp: p cmp10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns short +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns int +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns float +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns double +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns float _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char * +PASS: gdb.base/callfuncs.exp: set unwindonsignal off +PASS: gdb.base/callfuncs.exp: register contents after gdb function calls +PASS: gdb.base/callfuncs.exp: gdb function calls preserve register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at breakpoint in call dummy function +PASS: gdb.base/callfuncs.exp: continue from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: bt after continuing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after stop in call dummy +PASS: gdb.base/callfuncs.exp: continue after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint then do a finish +PASS: gdb.base/callfuncs.exp: finish from call dummy breakpoint returns correct value +PASS: gdb.base/callfuncs.exp: bt after finishing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after finish in call dummy +PASS: gdb.base/callfuncs.exp: finish after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint and then do a return +PASS: gdb.base/callfuncs.exp: back at main after return from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after return in call dummy +PASS: gdb.base/callfuncs.exp: return after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 1 +PASS: gdb.base/callfuncs.exp: stop at nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 2 +PASS: gdb.base/callfuncs.exp: stop at nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 3 +PASS: gdb.base/callfuncs.exp: stop at nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: register contents after nested call dummies +PASS: gdb.base/callfuncs.exp: nested call dummies preserve register contents +PASS: gdb.base/callfuncs.exp: set $old_sp = $sp +PASS: gdb.base/callfuncs.exp: set $sp = 0 +PASS: gdb.base/callfuncs.exp: sp == 0: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = -1 +PASS: gdb.base/callfuncs.exp: sp == -1: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = $old_sp +PASS: gdb.base/callfuncs.exp: print callfunc (Lcallfunc, 5) +PASS: gdb.base/callfuncs.exp: print *((int *(*) (void)) voidfunc)() +Running ./gdb.base/call-rt-st.exp ... +PASS: gdb.base/call-rt-st.exp: set print sevenbit-strings +PASS: gdb.base/call-rt-st.exp: set print address off +PASS: gdb.base/call-rt-st.exp: set width 0 +PASS: gdb.base/call-rt-st.exp: breakpoint loop_count +PASS: gdb.base/call-rt-st.exp: continue to loop_count +PASS: gdb.base/call-rt-st.exp: finish out from loop_count (line 777) +Running ./gdb.base/call-sc.exp ... +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tc (char) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tc char +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tc +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tc +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tc +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tc +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ts (short int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ts short int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ts +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ts +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ts +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ts +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ti (int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ti int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ti +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ti +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ti +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ti +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tl (long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tl long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tl +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tl +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tl +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tl +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tll (long long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tll long long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tll +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tll +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tll +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tll +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tf (float) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tf float +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tf +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tf +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tf +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tf +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-td (double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-td double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-td +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-td +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-td +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-td +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-td +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tld (long double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tld long double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tld +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tld +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tld +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tld +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-te (enum {e = 49}) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-te enum {e = 49} +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-te +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-te +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-te +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-te +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-te +Running ./gdb.base/call-signal-resume.exp ... +Running ./gdb.base/call-strs.exp ... +PASS: gdb.base/call-strs.exp: set print sevenbit-strings +PASS: gdb.base/call-strs.exp: set print address off +PASS: gdb.base/call-strs.exp: set print symbol off +PASS: gdb.base/call-strs.exp: set width 0 +PASS: gdb.base/call-strs.exp: step after assignment to s +PASS: gdb.base/call-strs.exp: next over strcpy +PASS: gdb.base/call-strs.exp: print buf +PASS: gdb.base/call-strs.exp: print s +Running ./gdb.base/catch-load.exp ... +PASS: gdb.base/catch-load.exp: plain load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain load: catch load +PASS: gdb.base/catch-load.exp: plain load: continue +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: catch load +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: rx load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx load: catch load catch-load-so +PASS: gdb.base/catch-load.exp: rx load: continue +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: catch load catch-load-so +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: non-matching load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching load: catch load zardoz +PASS: gdb.base/catch-load.exp: non-matching load: continue +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: catch load zardoz +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: plain unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain unload: catch unload +PASS: gdb.base/catch-load.exp: plain unload: continue +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: catch unload +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: rx unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx unload: catch unload catch-load-so +PASS: gdb.base/catch-load.exp: rx unload: continue +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: catch unload catch-load-so +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: non-matching unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching unload: catch unload zardoz +PASS: gdb.base/catch-load.exp: non-matching unload: continue +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: catch unload zardoz +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: continue +Running ./gdb.base/catch-signal.exp ... +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGHUP +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: 1: catch signal 1 +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGHUP SIGUSR2 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: catch signal SIGZARDOZ +PASS: gdb.base/catch-signal.exp: catch signal all +PASS: gdb.base/catch-signal.exp: catch signal all SIGHUP +PASS: gdb.base/catch-signal.exp: catch signal SIGHUP all +PASS: gdb.base/catch-signal.exp: set catchpoint '' for printing +PASS: gdb.base/catch-signal.exp: info break for '' +PASS: gdb.base/catch-signal.exp: save breakpoints for '' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for '' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP SIGUSR2' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: set catchpoint 'all' for printing +PASS: gdb.base/catch-signal.exp: info break for 'all' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'all' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'all' +Running ./gdb.base/catch-syscall.exp ... +Running ./gdb.base/charset.exp ... +PASS: gdb.base/charset.exp: show charset +PASS: gdb.base/charset.exp: show target-charset +PASS: gdb.base/charset.exp: check `show target-charset' against `show charset' +PASS: gdb.base/charset.exp: show host-charset +PASS: gdb.base/charset.exp: check `show host-charset' against `show charset' +PASS: gdb.base/charset.exp: try malformed `set charset' +PASS: gdb.base/charset.exp: try `set host-charset' with invalid charset +PASS: gdb.base/charset.exp: try `set target-charset' with invalid charset +PASS: gdb.base/charset.exp: capture valid host charsets +PASS: gdb.base/charset.exp: capture valid target charsets +PASS: gdb.base/charset.exp: try `set host-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set host-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set host-charset IBM1047' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: set breakpoint after all strings have been initialized +PASS: gdb.base/charset.exp: run until all strings have been initialized +PASS: gdb.base/charset.exp: get integer valueof "sizeof (wchar_t)" (4) +PASS: gdb.base/charset.exp: set host-charset ASCII +PASS: gdb.base/charset.exp: set target-charset ASCII +PASS: gdb.base/charset.exp: print the null character in ASCII +PASS: gdb.base/charset.exp: print string in ASCII +PASS: gdb.base/charset.exp: parse character literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed character literal in ASCII +PASS: gdb.base/charset.exp: parse string literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed string literal in ASCII +PASS: gdb.base/charset.exp: try printing '\a' in ASCII +PASS: gdb.base/charset.exp: check value of '\a' in ASCII +PASS: gdb.base/charset.exp: check value of "\a" in ASCII +PASS: gdb.base/charset.exp: try printing '\b' in ASCII +PASS: gdb.base/charset.exp: check value of '\b' in ASCII +PASS: gdb.base/charset.exp: check value of "\b" in ASCII +PASS: gdb.base/charset.exp: try printing '\f' in ASCII +PASS: gdb.base/charset.exp: check value of '\f' in ASCII +PASS: gdb.base/charset.exp: check value of "\f" in ASCII +PASS: gdb.base/charset.exp: try printing '\n' in ASCII +PASS: gdb.base/charset.exp: check value of '\n' in ASCII +PASS: gdb.base/charset.exp: check value of "\n" in ASCII +PASS: gdb.base/charset.exp: try printing '\r' in ASCII +PASS: gdb.base/charset.exp: check value of '\r' in ASCII +PASS: gdb.base/charset.exp: check value of "\r" in ASCII +PASS: gdb.base/charset.exp: try printing '\t' in ASCII +PASS: gdb.base/charset.exp: check value of '\t' in ASCII +PASS: gdb.base/charset.exp: check value of "\t" in ASCII +PASS: gdb.base/charset.exp: try printing '\v' in ASCII +PASS: gdb.base/charset.exp: check value of '\v' in ASCII +PASS: gdb.base/charset.exp: check value of "\v" in ASCII +PASS: gdb.base/charset.exp: print escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: set target-charset ISO-8859-1 +PASS: gdb.base/charset.exp: print the null character in ISO-8859-1 +PASS: gdb.base/charset.exp: print string in ISO-8859-1 +PASS: gdb.base/charset.exp: parse character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: parse string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\a" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\b" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\f" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\n" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\r" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\t" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\v" in ISO-8859-1 +PASS: gdb.base/charset.exp: print escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: set target-charset EBCDIC-US +PASS: gdb.base/charset.exp: print the null character in EBCDIC-US +PASS: gdb.base/charset.exp: print string in EBCDIC-US +PASS: gdb.base/charset.exp: parse character literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed character literal in EBCDIC-US +PASS: gdb.base/charset.exp: parse string literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed string literal in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\a" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\b" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\f" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\n" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\r" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\t" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\v" in EBCDIC-US +PASS: gdb.base/charset.exp: print escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: set target-charset IBM1047 +PASS: gdb.base/charset.exp: print the null character in IBM1047 +PASS: gdb.base/charset.exp: print string in IBM1047 +PASS: gdb.base/charset.exp: parse character literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed character literal in IBM1047 +PASS: gdb.base/charset.exp: parse string literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed string literal in IBM1047 +PASS: gdb.base/charset.exp: try printing '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\a" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\b" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\f" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\n" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\r" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\t" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\v" in IBM1047 +PASS: gdb.base/charset.exp: print escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: set target-wide-charset UTF-32 +PASS: gdb.base/charset.exp: print the null character in UTF-32 +PASS: gdb.base/charset.exp: print string in UTF-32 +PASS: gdb.base/charset.exp: parse character literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed character literal in UTF-32 +PASS: gdb.base/charset.exp: parse string literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed string literal in UTF-32 +PASS: gdb.base/charset.exp: try printing '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\a" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\b" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\f" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\n" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\r" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\t" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\v" in UTF-32 +PASS: gdb.base/charset.exp: print escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: set target-charset UTF-8 +PASS: gdb.base/charset.exp: non-representable target character +PASS: gdb.base/charset.exp: print '\x' +PASS: gdb.base/charset.exp: print '\u' +PASS: gdb.base/charset.exp: print '\9' +PASS: gdb.base/charset.exp: print "\1011" +PASS: gdb.base/charset.exp: basic wide string concatenation +PASS: gdb.base/charset.exp: narrow and wide string concatenation +PASS: gdb.base/charset.exp: wide and narrow string concatenation +PASS: gdb.base/charset.exp: wide string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty wide string +PASS: gdb.base/charset.exp: basic wide character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char16_t)" (2) +PASS: gdb.base/charset.exp: basic UTF-16 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-16 string concatenation +PASS: gdb.base/charset.exp: UTF-16 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-16 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-16 string +PASS: gdb.base/charset.exp: basic UTF-16 character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char32_t)" (4) +PASS: gdb.base/charset.exp: basic UTF-32 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-32 string concatenation +PASS: gdb.base/charset.exp: UTF-32 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-32 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-32 string +PASS: gdb.base/charset.exp: basic UTF-32 character +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-16 +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-32 +PASS: gdb.base/charset.exp: typedef to wchar_t +PASS: gdb.base/charset.exp: undefined concatenation of UTF-16 and UTF-32 +PASS: gdb.base/charset.exp: set up for python printing of utf-16 string +PASS: gdb.base/charset.exp: extract utf-16 string using python +PASS: gdb.base/charset.exp: EVAL_SKIP cleanup handling regression test +PASS: gdb.base/charset.exp: Assign String16 with prefix u +PASS: gdb.base/charset.exp: Display String String16 with x/hs +PASS: gdb.base/charset.exp: Assign String32 with prefix U +PASS: gdb.base/charset.exp: Display String String32 with x/ws +PASS: gdb.base/charset.exp: Assign String32 with prefix L +PASS: gdb.base/charset.exp: Display String String32 with x/ws +PASS: gdb.base/charset.exp: assign string to short array +PASS: gdb.base/charset.exp: assign string to int array +PASS: gdb.base/charset.exp: assign string to long array +Running ./gdb.base/checkpoint.exp ... +Running ./gdb.base/chng-syms.exp ... +PASS: gdb.base/chng-syms.exp: setting conditional breakpoint on function +PASS: gdb.base/chng-syms.exp: continue until exit at breakpoint first time through +PASS: gdb.base/chng-syms.exp: running with invalidated bpt condition after executable changes +Running ./gdb.base/code_elim.exp ... +PASS: gdb.base/code_elim.exp: symbol-file code_elim1 +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single psymtabs: get address of main +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single symtabs: get address of main +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order1: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_global_func +PASS: gdb.base/code_elim.exp: order1: get address of main +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order2: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_global_func +PASS: gdb.base/code_elim.exp: order2: get address of main +Running ./gdb.base/code-expr.exp ... +PASS: gdb.base/code-expr.exp: set print sevenbit-strings +PASS: gdb.base/code-expr.exp: set print address off +PASS: gdb.base/code-expr.exp: set width 0 +PASS: gdb.base/code-expr.exp: (@code char) +PASS: gdb.base/code-expr.exp: (@code signed char) +PASS: gdb.base/code-expr.exp: (@code unsigned char) +PASS: gdb.base/code-expr.exp: (@code short) +PASS: gdb.base/code-expr.exp: (@code signed short) +PASS: gdb.base/code-expr.exp: (@code unsigned short) +PASS: gdb.base/code-expr.exp: (@code int) +PASS: gdb.base/code-expr.exp: (@code signed int) +PASS: gdb.base/code-expr.exp: (@code unsigned int) +PASS: gdb.base/code-expr.exp: (@code long) +PASS: gdb.base/code-expr.exp: (@code signed long) +PASS: gdb.base/code-expr.exp: (@code unsigned long) +PASS: gdb.base/code-expr.exp: (@code long long) +PASS: gdb.base/code-expr.exp: (@code signed long long) +PASS: gdb.base/code-expr.exp: (@code unsigned long long) +PASS: gdb.base/code-expr.exp: (@code float) +PASS: gdb.base/code-expr.exp: (@code double) +PASS: gdb.base/code-expr.exp: (@data char) +PASS: gdb.base/code-expr.exp: (@data signed char) +PASS: gdb.base/code-expr.exp: (@data unsigned char) +PASS: gdb.base/code-expr.exp: (@data short) +PASS: gdb.base/code-expr.exp: (@data signed short) +PASS: gdb.base/code-expr.exp: (@data unsigned short) +PASS: gdb.base/code-expr.exp: (@data int) +PASS: gdb.base/code-expr.exp: (@data signed int) +PASS: gdb.base/code-expr.exp: (@data unsigned int) +PASS: gdb.base/code-expr.exp: (@data long) +PASS: gdb.base/code-expr.exp: (@data signed long) +PASS: gdb.base/code-expr.exp: (@data unsigned long) +PASS: gdb.base/code-expr.exp: (@data long long) +PASS: gdb.base/code-expr.exp: (@data signed long long) +PASS: gdb.base/code-expr.exp: (@data unsigned long long) +PASS: gdb.base/code-expr.exp: (@data float) +PASS: gdb.base/code-expr.exp: (@data double) +PASS: gdb.base/code-expr.exp: (char @code) +PASS: gdb.base/code-expr.exp: (signed char @code) +PASS: gdb.base/code-expr.exp: (unsigned char @code) +PASS: gdb.base/code-expr.exp: (short @code) +PASS: gdb.base/code-expr.exp: (signed short @code) +PASS: gdb.base/code-expr.exp: (unsigned short @code) +PASS: gdb.base/code-expr.exp: (int @code) +PASS: gdb.base/code-expr.exp: (signed int @code) +PASS: gdb.base/code-expr.exp: (unsigned int @code) +PASS: gdb.base/code-expr.exp: (long @code) +PASS: gdb.base/code-expr.exp: (signed long @code) +PASS: gdb.base/code-expr.exp: (unsigned long @code) +PASS: gdb.base/code-expr.exp: (long long @code) +PASS: gdb.base/code-expr.exp: (signed long long @code) +PASS: gdb.base/code-expr.exp: (unsigned long long @code) +PASS: gdb.base/code-expr.exp: (float @code) +PASS: gdb.base/code-expr.exp: (double @code) +PASS: gdb.base/code-expr.exp: (char @data) +PASS: gdb.base/code-expr.exp: (signed char @data) +PASS: gdb.base/code-expr.exp: (unsigned char @data) +PASS: gdb.base/code-expr.exp: (short @data) +PASS: gdb.base/code-expr.exp: (signed short @data) +PASS: gdb.base/code-expr.exp: (unsigned short @data) +PASS: gdb.base/code-expr.exp: (int @data) +PASS: gdb.base/code-expr.exp: (signed int @data) +PASS: gdb.base/code-expr.exp: (unsigned int @data) +PASS: gdb.base/code-expr.exp: (long @data) +PASS: gdb.base/code-expr.exp: (signed long @data) +PASS: gdb.base/code-expr.exp: (unsigned long @data) +PASS: gdb.base/code-expr.exp: (long long @data) +PASS: gdb.base/code-expr.exp: (signed long long @data) +PASS: gdb.base/code-expr.exp: (unsigned long long @data) +PASS: gdb.base/code-expr.exp: (float @data) +PASS: gdb.base/code-expr.exp: (double @data) +PASS: gdb.base/code-expr.exp: (@code enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @code) +PASS: gdb.base/code-expr.exp: (@data enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @data) +PASS: gdb.base/code-expr.exp: (@code int *) +PASS: gdb.base/code-expr.exp: (int @code *) +PASS: gdb.base/code-expr.exp: (int * @code) +PASS: gdb.base/code-expr.exp: (@code int * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code) +PASS: gdb.base/code-expr.exp: (@code int **) +PASS: gdb.base/code-expr.exp: (int @code **) +PASS: gdb.base/code-expr.exp: (int ** @code) +PASS: gdb.base/code-expr.exp: (@code int * @code *) +PASS: gdb.base/code-expr.exp: (int @code * @code *) +PASS: gdb.base/code-expr.exp: (@code int * @code * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct) +PASS: gdb.base/code-expr.exp: (@code union t_union) +PASS: gdb.base/code-expr.exp: (struct t_struct @code) +PASS: gdb.base/code-expr.exp: (union t_union @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct *) +PASS: gdb.base/code-expr.exp: (@code union t_union *) +PASS: gdb.base/code-expr.exp: (struct t_struct @code *) +PASS: gdb.base/code-expr.exp: (union t_union @code *) +PASS: gdb.base/code-expr.exp: (struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (union t_union * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (@code union t_union * @code) +PASS: gdb.base/code-expr.exp: (struct t_struct @code * @code) +PASS: gdb.base/code-expr.exp: (union t_union @code * @code) +Running ./gdb.base/commands.exp ... +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_if_test +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #1 +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #2 +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_while_test +PASS: gdb.base/commands.exp: gdbvar_simple_while_test #1 +PASS: gdb.base/commands.exp: set foo in gdbvar complex_if_while_test +PASS: gdb.base/commands.exp: gdbvar_complex_if_while_test #1 +PASS: gdb.base/commands.exp: set foo in user_defined_command_test +PASS: gdb.base/commands.exp: define mycommand in user_defined_command_test +PASS: gdb.base/commands.exp: enter commands in user_defined_command_test +PASS: gdb.base/commands.exp: execute user defined command in user_defined_command_test +PASS: gdb.base/commands.exp: display user command in user_defined_command_test +PASS: gdb.base/commands.exp: tried to deprecate non-existing command +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /1/ +PASS: gdb.base/commands.exp: p deprecated warning, with replacement +PASS: gdb.base/commands.exp: Deprecated warning goes away /1/ +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /2/ +PASS: gdb.base/commands.exp: maintenance deprecate print "new_print" +PASS: gdb.base/commands.exp: both alias and command are deprecated +PASS: gdb.base/commands.exp: Deprecated warning goes away /2/ +PASS: gdb.base/commands.exp: deprecate long command /1/ +PASS: gdb.base/commands.exp: long command deprecated /1/ +PASS: gdb.base/commands.exp: deprecate long command /2/ +PASS: gdb.base/commands.exp: long command deprecated with no alternative /2/ +PASS: gdb.base/commands.exp: deprecate with no arguments +PASS: gdb.base/commands.exp: stray_arg0_test #1 +PASS: gdb.base/commands.exp: stray_arg0_test #2 +PASS: gdb.base/commands.exp: stray_arg0_test #3 +PASS: gdb.base/commands.exp: stray_arg0_test #4 +PASS: gdb.base/commands.exp: source file with indented comment +PASS: gdb.base/commands.exp: recursive source test +PASS: gdb.base/commands.exp: set $tem in if_commands_test +PASS: gdb.base/commands.exp: if $tem == 2 - if_commands_test 1 +PASS: gdb.base/commands.exp: break main - if_commands_test 1 +PASS: gdb.base/commands.exp: else - if_commands_test 1 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 1 +PASS: gdb.base/commands.exp: commands - if_commands_test 1 +PASS: gdb.base/commands.exp: silent - if_commands_test 1 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 1 +PASS: gdb.base/commands.exp: continue - if_commands_test 1 +PASS: gdb.base/commands.exp: first end - if_commands_test 1 +PASS: gdb.base/commands.exp: second end - if_commands_test 1 +PASS: gdb.base/commands.exp: if $tem == 1 - if_commands_test 2 +PASS: gdb.base/commands.exp: break main - if_commands_test 2 +PASS: gdb.base/commands.exp: else - if_commands_test 2 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 2 +PASS: gdb.base/commands.exp: commands - if_commands_test 2 +PASS: gdb.base/commands.exp: silent - if_commands_test 2 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 2 +PASS: gdb.base/commands.exp: continue - if_commands_test 2 +PASS: gdb.base/commands.exp: first end - if_commands_test 2 +PASS: gdb.base/commands.exp: second end - if_commands_test 2 +PASS: gdb.base/commands.exp: hook-stop 1 +PASS: gdb.base/commands.exp: hook-stop 1a +PASS: gdb.base/commands.exp: hook-stop 1b +PASS: gdb.base/commands.exp: main commands 1 +PASS: gdb.base/commands.exp: main commands 1a +PASS: gdb.base/commands.exp: main commands 1b +PASS: gdb.base/commands.exp: main commands 1c +PASS: gdb.base/commands.exp: main commands 2 +PASS: gdb.base/commands.exp: main commands 2a +PASS: gdb.base/commands.exp: main commands 2b +PASS: gdb.base/commands.exp: main commands 2c +PASS: gdb.base/commands.exp: cmd1 error +PASS: gdb.base/commands.exp: no cmd2 +PASS: gdb.base/commands.exp: define one +PASS: gdb.base/commands.exp: define hook-one +PASS: gdb.base/commands.exp: define one in redefine_hook_test +PASS: gdb.base/commands.exp: enter commands for one redefinition in redefine_hook_test +PASS: gdb.base/commands.exp: execute one command in redefine_hook_test +PASS: gdb.base/commands.exp: define backtrace +PASS: gdb.base/commands.exp: expect response to define backtrace +PASS: gdb.base/commands.exp: enter commands in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute backtrace command in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute bt command in redefine_backtrace_test +Running ./gdb.base/completion.exp ... +PASS: gdb.base/completion.exp: complete 'hfgfh' +PASS: gdb.base/completion.exp: complete 'show output' +PASS: gdb.base/completion.exp: complete 'show output-' +PASS: gdb.base/completion.exp: complete 'p' +PASS: gdb.base/completion.exp: complete 'p ' +PASS: gdb.base/completion.exp: complete 'info t foo' +PASS: gdb.base/completion.exp: complete 'info t' +PASS: gdb.base/completion.exp: complete 'info t ' +PASS: gdb.base/completion.exp: complete 'info asdfgh' +PASS: gdb.base/completion.exp: complete 'info asdfgh ' +PASS: gdb.base/completion.exp: complete 'info' +PASS: gdb.base/completion.exp: complete 'info ' +PASS: gdb.base/completion.exp: complete (2) 'info ' +PASS: gdb.base/completion.exp: complete 'help info wat' +PASS: gdb.base/completion.exp: complete 'p "break1' +XFAIL: gdb.base/completion.exp: complete 'p "break1.' +PASS: gdb.base/completion.exp: complete 'p 'arg' +PASS: gdb.base/completion.exp: complete (2) 'p 'arg' +PASS: gdb.base/completion.exp: complete 'handle signal' +PASS: gdb.base/completion.exp: complete 'handle keyword' +PASS: gdb.base/completion.exp: complete help aliases +PASS: gdb.base/completion.exp: complete 'p no_var_named_this-arg' +PASS: gdb.base/completion.exp: complete (2) 'p no_var_named_this-arg' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete (2) 'p no_var_named_this-' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p values[0].a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p values[0] . a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p &values[0] -> a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: completion of field in anonymous union +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: ptype completion of field in anonymous union +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: whatis completion of field in anonymous union +PASS: gdb.base/completion.exp: cd to ${srcdir} +PASS: gdb.base/completion.exp: directory completion +PASS: gdb.base/completion.exp: directory completion 2 +PASS: gdb.base/completion.exp: Glob remaining of directory test +PASS: gdb.base/completion.exp: complete-command 'file ./gdb.base/compl' +PASS: gdb.base/completion.exp: complete 'file ./gdb.base/complet' +PASS: gdb.base/completion.exp: complete 'info func marke' +PASS: gdb.base/completion.exp: complete 'set follow-fork-mode' +PASS: gdb.base/completion.exp: field completion with invalid field +PASS: gdb.base/completion.exp: test non-deprecated completion +PASS: gdb.base/completion.exp: test deprecated completion +PASS: gdb.base/completion.exp: complete ptype struct some_ +PASS: gdb.base/completion.exp: complete ptype enum some_ +PASS: gdb.base/completion.exp: complete ptype union some_ +PASS: gdb.base/completion.exp: complete set gnutarget aut +PASS: gdb.base/completion.exp: complete set cp-abi aut +Running ./gdb.base/complex.exp ... +PASS: gdb.base/complex.exp: print complex packed value in C +PASS: gdb.base/complex.exp: print complex value in C +Running ./gdb.base/comprdebug.exp ... +PASS: gdb.base/comprdebug.exp: file comprdebug0.o +Running ./gdb.base/condbreak.exp ... +PASS: gdb.base/condbreak.exp: breakpoint function +PASS: gdb.base/condbreak.exp: break marker1 if 1==1 +PASS: gdb.base/condbreak.exp: delete 2 +PASS: gdb.base/condbreak.exp: break break.c:92 if 1==1 +PASS: gdb.base/condbreak.exp: delete 3 +PASS: gdb.base/condbreak.exp: break marker1 if (1==1) +PASS: gdb.base/condbreak.exp: break break.c:92 if (1==1) +PASS: gdb.base/condbreak.exp: break marker2 if (a==43) +PASS: gdb.base/condbreak.exp: break marker3 if (multi_line_if_conditional(1,1,1)==0) +PASS: gdb.base/condbreak.exp: break marker4 +PASS: gdb.base/condbreak.exp: breakpoint info +PASS: gdb.base/condbreak.exp: rerun to main +PASS: gdb.base/condbreak.exp: run until breakpoint set at a line number +PASS: gdb.base/condbreak.exp: run until breakpoint at marker1 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker2 +PASS: gdb.base/condbreak.exp: break main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break *main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) task 999 +PASS: gdb.base/condbreak.exp: break *main task 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) t 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) th 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) ta 999 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker3 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker4 +PASS: gdb.base/condbreak.exp: complete cond 1 +PASS: gdb.base/condbreak.exp: set variable $var = 1 +PASS: gdb.base/condbreak.exp: complete cond $v +PASS: gdb.base/condbreak.exp: complete cond 1 values[0].a +Running ./gdb.base/cond-eval-mode.exp ... +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation host +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation auto +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation target +Running ./gdb.base/cond-expr.exp ... +PASS: gdb.base/cond-expr.exp: print value of cond expr (const true) +PASS: gdb.base/cond-expr.exp: print value of cond expr (const false) +PASS: gdb.base/cond-expr.exp: set variable x=14 +PASS: gdb.base/cond-expr.exp: set variable y=2 +PASS: gdb.base/cond-expr.exp: set variable z=3 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var true) +PASS: gdb.base/cond-expr.exp: set variable x=0 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var false) +PASS: gdb.base/cond-expr.exp: print whatis of cond expr +Running ./gdb.base/consecutive.exp ... +PASS: gdb.base/consecutive.exp: continue to breakpoint in foo +PASS: gdb.base/consecutive.exp: get breakpoint address for foo +PASS: gdb.base/consecutive.exp: set bp, 2nd instr +PASS: gdb.base/consecutive.exp: stopped at bp, 2nd instr +Running ./gdb.base/constvars.exp ... +PASS: gdb.base/constvars.exp: break marker1 +PASS: gdb.base/constvars.exp: continue to marker1 +PASS: gdb.base/constvars.exp: up from marker1 +PASS: gdb.base/constvars.exp: ptype qux1 +PASS: gdb.base/constvars.exp: print lave +PASS: gdb.base/constvars.exp: ptype lave +PASS: gdb.base/constvars.exp: print lavish +PASS: gdb.base/constvars.exp: ptype lavish +PASS: gdb.base/constvars.exp: print lax +PASS: gdb.base/constvars.exp: ptype lax +PASS: gdb.base/constvars.exp: print lecherous +PASS: gdb.base/constvars.exp: ptype lecherous +PASS: gdb.base/constvars.exp: print lechery +PASS: gdb.base/constvars.exp: ptype lechery +PASS: gdb.base/constvars.exp: print lectern +PASS: gdb.base/constvars.exp: ptype lectern +PASS: gdb.base/constvars.exp: print leeway +PASS: gdb.base/constvars.exp: ptype leeway +PASS: gdb.base/constvars.exp: print legacy +PASS: gdb.base/constvars.exp: ptype legacy +PASS: gdb.base/constvars.exp: print laconic +PASS: gdb.base/constvars.exp: ptype laconic +PASS: gdb.base/constvars.exp: print laggard +PASS: gdb.base/constvars.exp: ptype laggard +PASS: gdb.base/constvars.exp: print lagoon +PASS: gdb.base/constvars.exp: ptype lagoon +PASS: gdb.base/constvars.exp: print laity +PASS: gdb.base/constvars.exp: ptype laity +PASS: gdb.base/constvars.exp: print lambent +PASS: gdb.base/constvars.exp: ptype lambent +PASS: gdb.base/constvars.exp: print laminated +PASS: gdb.base/constvars.exp: ptype laminated +PASS: gdb.base/constvars.exp: print lampoon +PASS: gdb.base/constvars.exp: ptype lampoon +PASS: gdb.base/constvars.exp: print languid +PASS: gdb.base/constvars.exp: ptype languid +PASS: gdb.base/constvars.exp: print *legend +PASS: gdb.base/constvars.exp: ptype legend +PASS: gdb.base/constvars.exp: print *legerdemain +PASS: gdb.base/constvars.exp: ptype legerdemain +PASS: gdb.base/constvars.exp: print *leniency +PASS: gdb.base/constvars.exp: ptype leniency +PASS: gdb.base/constvars.exp: print *leonine +PASS: gdb.base/constvars.exp: ptype leonine +PASS: gdb.base/constvars.exp: print *lesion +PASS: gdb.base/constvars.exp: ptype lesion +PASS: gdb.base/constvars.exp: print *lethal +PASS: gdb.base/constvars.exp: ptype lethal +PASS: gdb.base/constvars.exp: print *lethargic +PASS: gdb.base/constvars.exp: ptype lethargic +PASS: gdb.base/constvars.exp: print *levity +PASS: gdb.base/constvars.exp: ptype levity +PASS: gdb.base/constvars.exp: print *lewd +PASS: gdb.base/constvars.exp: ptype lewd +PASS: gdb.base/constvars.exp: print *lexicographer +PASS: gdb.base/constvars.exp: ptype lexicographer +PASS: gdb.base/constvars.exp: print *lexicon +PASS: gdb.base/constvars.exp: ptype lexicon +PASS: gdb.base/constvars.exp: print *liaison +PASS: gdb.base/constvars.exp: ptype liaison +PASS: gdb.base/constvars.exp: print *libation +PASS: gdb.base/constvars.exp: ptype libation +PASS: gdb.base/constvars.exp: print *libelous +PASS: gdb.base/constvars.exp: ptype libelous +PASS: gdb.base/constvars.exp: print *libertine +PASS: gdb.base/constvars.exp: ptype libertine +PASS: gdb.base/constvars.exp: print *libidinous +PASS: gdb.base/constvars.exp: ptype libidinous +PASS: gdb.base/constvars.exp: print *languish +PASS: gdb.base/constvars.exp: ptype languish +PASS: gdb.base/constvars.exp: print *languor +PASS: gdb.base/constvars.exp: ptype languor +PASS: gdb.base/constvars.exp: print *lank +PASS: gdb.base/constvars.exp: ptype lank +PASS: gdb.base/constvars.exp: print *lapidary +PASS: gdb.base/constvars.exp: ptype lapidary +PASS: gdb.base/constvars.exp: print *larceny +PASS: gdb.base/constvars.exp: ptype larceny +PASS: gdb.base/constvars.exp: print *largess +PASS: gdb.base/constvars.exp: ptype largess +PASS: gdb.base/constvars.exp: print *lascivious +PASS: gdb.base/constvars.exp: ptype lascivious +PASS: gdb.base/constvars.exp: print *lassitude +PASS: gdb.base/constvars.exp: ptype lassitude +PASS: gdb.base/constvars.exp: print *lamprey +PASS: gdb.base/constvars.exp: ptype lamprey +PASS: gdb.base/constvars.exp: print *lariat +PASS: gdb.base/constvars.exp: ptype lariat +PASS: gdb.base/constvars.exp: print *laudanum +PASS: gdb.base/constvars.exp: ptype laudanum +PASS: gdb.base/constvars.exp: print *lecithin +PASS: gdb.base/constvars.exp: ptype lecithin +PASS: gdb.base/constvars.exp: print *leviathan +PASS: gdb.base/constvars.exp: ptype leviathan +PASS: gdb.base/constvars.exp: print *libretto +PASS: gdb.base/constvars.exp: ptype libretto +PASS: gdb.base/constvars.exp: print *lissome +PASS: gdb.base/constvars.exp: ptype lissome +PASS: gdb.base/constvars.exp: print *locust +PASS: gdb.base/constvars.exp: ptype locust +PASS: gdb.base/constvars.exp: ptype logical +PASS: gdb.base/constvars.exp: ptype lugged +PASS: gdb.base/constvars.exp: ptype luck +PASS: gdb.base/constvars.exp: ptype lunar +PASS: gdb.base/constvars.exp: ptype lumen +PASS: gdb.base/constvars.exp: ptype lurk +PASS: gdb.base/constvars.exp: ptype lush +PASS: gdb.base/constvars.exp: ptype lynx +PASS: gdb.base/constvars.exp: ptype crass +PASS: gdb.base/constvars.exp: ptype crisp +Running ./gdb.base/corefile.exp ... +Running ./gdb.base/ctxobj.exp ... +PASS: gdb.base/ctxobj.exp: break in get_version functions +PASS: gdb.base/ctxobj.exp: continue to get_version_1 +PASS: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from partial symtab +PASS: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from symtab +PASS: gdb.base/ctxobj.exp: continue to get_version_2 +PASS: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from partial symtab +PASS: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from symtab +Running ./gdb.base/cursal.exp ... +PASS: gdb.base/cursal.exp: set listsize 1 +PASS: gdb.base/cursal.exp: list before run +PASS: gdb.base/cursal.exp: list in main +PASS: gdb.base/cursal.exp: list in func2 +PASS: gdb.base/cursal.exp: backtrace +PASS: gdb.base/cursal.exp: list after backtrace +PASS: gdb.base/cursal.exp: set listsize 3 +PASS: gdb.base/cursal.exp: list size 3 +Running ./gdb.base/cvexpr.exp ... +PASS: gdb.base/cvexpr.exp: set print sevenbit-strings +PASS: gdb.base/cvexpr.exp: set print address off +PASS: gdb.base/cvexpr.exp: set width 0 +PASS: gdb.base/cvexpr.exp: (const char) +PASS: gdb.base/cvexpr.exp: (const signed char) +PASS: gdb.base/cvexpr.exp: (const unsigned char) +PASS: gdb.base/cvexpr.exp: (const short) +PASS: gdb.base/cvexpr.exp: (const signed short) +PASS: gdb.base/cvexpr.exp: (const unsigned short) +PASS: gdb.base/cvexpr.exp: (const int) +PASS: gdb.base/cvexpr.exp: (const signed int) +PASS: gdb.base/cvexpr.exp: (const unsigned int) +PASS: gdb.base/cvexpr.exp: (const long) +PASS: gdb.base/cvexpr.exp: (const signed long) +PASS: gdb.base/cvexpr.exp: (const unsigned long) +PASS: gdb.base/cvexpr.exp: (const long long) +PASS: gdb.base/cvexpr.exp: (const signed long long) +PASS: gdb.base/cvexpr.exp: (const unsigned long long) +PASS: gdb.base/cvexpr.exp: (const float) +PASS: gdb.base/cvexpr.exp: (const double) +PASS: gdb.base/cvexpr.exp: (volatile char) +PASS: gdb.base/cvexpr.exp: (volatile signed char) +PASS: gdb.base/cvexpr.exp: (volatile unsigned char) +PASS: gdb.base/cvexpr.exp: (volatile short) +PASS: gdb.base/cvexpr.exp: (volatile signed short) +PASS: gdb.base/cvexpr.exp: (volatile unsigned short) +PASS: gdb.base/cvexpr.exp: (volatile int) +PASS: gdb.base/cvexpr.exp: (volatile signed int) +PASS: gdb.base/cvexpr.exp: (volatile unsigned int) +PASS: gdb.base/cvexpr.exp: (volatile long) +PASS: gdb.base/cvexpr.exp: (volatile signed long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long) +PASS: gdb.base/cvexpr.exp: (volatile long long) +PASS: gdb.base/cvexpr.exp: (volatile signed long long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long long) +PASS: gdb.base/cvexpr.exp: (volatile float) +PASS: gdb.base/cvexpr.exp: (volatile double) +PASS: gdb.base/cvexpr.exp: (const volatile int) +PASS: gdb.base/cvexpr.exp: (volatile const int) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const) +PASS: gdb.base/cvexpr.exp: (int const volatile) +PASS: gdb.base/cvexpr.exp: (int volatile const) +PASS: gdb.base/cvexpr.exp: (const volatile int *) +PASS: gdb.base/cvexpr.exp: (volatile const int *) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const *) +PASS: gdb.base/cvexpr.exp: (int const volatile *) +PASS: gdb.base/cvexpr.exp: (int volatile const *) +PASS: gdb.base/cvexpr.exp: (int * const volatile) +PASS: gdb.base/cvexpr.exp: (int * volatile const) +PASS: gdb.base/cvexpr.exp: (char const) +PASS: gdb.base/cvexpr.exp: (signed char const) +PASS: gdb.base/cvexpr.exp: (unsigned char const) +PASS: gdb.base/cvexpr.exp: (short const) +PASS: gdb.base/cvexpr.exp: (signed short const) +PASS: gdb.base/cvexpr.exp: (unsigned short const) +PASS: gdb.base/cvexpr.exp: (int const) +PASS: gdb.base/cvexpr.exp: (signed int const) +PASS: gdb.base/cvexpr.exp: (unsigned int const) +PASS: gdb.base/cvexpr.exp: (long const) +PASS: gdb.base/cvexpr.exp: (signed long const) +PASS: gdb.base/cvexpr.exp: (unsigned long const) +PASS: gdb.base/cvexpr.exp: (long long const) +PASS: gdb.base/cvexpr.exp: (signed long long const) +PASS: gdb.base/cvexpr.exp: (unsigned long long const) +PASS: gdb.base/cvexpr.exp: (float const) +PASS: gdb.base/cvexpr.exp: (double const) +PASS: gdb.base/cvexpr.exp: (char volatile) +PASS: gdb.base/cvexpr.exp: (signed char volatile) +PASS: gdb.base/cvexpr.exp: (unsigned char volatile) +PASS: gdb.base/cvexpr.exp: (short volatile) +PASS: gdb.base/cvexpr.exp: (signed short volatile) +PASS: gdb.base/cvexpr.exp: (unsigned short volatile) +PASS: gdb.base/cvexpr.exp: (int volatile) +PASS: gdb.base/cvexpr.exp: (signed int volatile) +PASS: gdb.base/cvexpr.exp: (unsigned int volatile) +PASS: gdb.base/cvexpr.exp: (long volatile) +PASS: gdb.base/cvexpr.exp: (signed long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long volatile) +PASS: gdb.base/cvexpr.exp: (long long volatile) +PASS: gdb.base/cvexpr.exp: (signed long long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long long volatile) +PASS: gdb.base/cvexpr.exp: (float volatile) +PASS: gdb.base/cvexpr.exp: (double volatile) +PASS: gdb.base/cvexpr.exp: (const enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered const) +PASS: gdb.base/cvexpr.exp: (volatile enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered volatile) +PASS: gdb.base/cvexpr.exp: (const int *) +PASS: gdb.base/cvexpr.exp: (int const *) +PASS: gdb.base/cvexpr.exp: (int * const) +PASS: gdb.base/cvexpr.exp: (const int * const) +PASS: gdb.base/cvexpr.exp: (int const * const) +PASS: gdb.base/cvexpr.exp: (const int **) +PASS: gdb.base/cvexpr.exp: (int const **) +PASS: gdb.base/cvexpr.exp: (int ** const) +PASS: gdb.base/cvexpr.exp: (const int * const *) +PASS: gdb.base/cvexpr.exp: (int const * const *) +PASS: gdb.base/cvexpr.exp: (const int * const * const) +PASS: gdb.base/cvexpr.exp: (int const * const * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct) +PASS: gdb.base/cvexpr.exp: (const union t_union) +PASS: gdb.base/cvexpr.exp: (struct t_struct const) +PASS: gdb.base/cvexpr.exp: (union t_union const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct *) +PASS: gdb.base/cvexpr.exp: (const union t_union *) +PASS: gdb.base/cvexpr.exp: (struct t_struct const *) +PASS: gdb.base/cvexpr.exp: (union t_union const *) +PASS: gdb.base/cvexpr.exp: (struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (union t_union * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (const union t_union * const) +PASS: gdb.base/cvexpr.exp: (struct t_struct const * const) +PASS: gdb.base/cvexpr.exp: (union t_union const * const) +Running ./gdb.base/dbx.exp ... +PASS: gdb.base/dbx.exp: stop in main +PASS: gdb.base/dbx.exp: status +PASS: gdb.base/dbx.exp: stop at average.c:43 +PASS: gdb.base/dbx.exp: stop in average.c:43 +PASS: gdb.base/dbx.exp: stop at main +PASS: gdb.base/dbx.exp: running to main +PASS: gdb.base/dbx.exp: assign first +PASS: gdb.base/dbx.exp: print first +PASS: gdb.base/dbx.exp: whereis my_list +PASS: gdb.base/dbx.exp: file average.c:1 +PASS: gdb.base/dbx.exp: cont 1 +PASS: gdb.base/dbx.exp: step +XFAIL: gdb.base/dbx.exp: func sum +PASS: gdb.base/dbx.exp: stop in sum +PASS: gdb.base/dbx.exp: cont 2 +XFAIL: gdb.base/dbx.exp: func print_average +Running ./gdb.base/debug-expr.exp ... +PASS: gdb.base/debug-expr.exp: set variable array[0] = 0 +PASS: gdb.base/debug-expr.exp: set variable array[1] = 1 +PASS: gdb.base/debug-expr.exp: set variable array[2] = 2 +PASS: gdb.base/debug-expr.exp: set variable array[3] = 3 +PASS: gdb.base/debug-expr.exp: set debug expression 1 +PASS: gdb.base/debug-expr.exp: print /x {char[4]} array +Running ./gdb.base/default.exp ... +PASS: gdb.base/default.exp: add-symbol-file +PASS: gdb.base/default.exp: append +PASS: gdb.base/default.exp: append binary +PASS: gdb.base/default.exp: append memory +PASS: gdb.base/default.exp: append value +PASS: gdb.base/default.exp: append binary memory +PASS: gdb.base/default.exp: append binary value +WARNING: Skipping backtrace and break tests because of GDB stub. +PASS: gdb.base/default.exp: continue +PASS: gdb.base/default.exp: continue "c" abbreviation +PASS: gdb.base/default.exp: call +PASS: gdb.base/default.exp: catch +PASS: gdb.base/default.exp: cd +PASS: gdb.base/default.exp: clear +PASS: gdb.base/default.exp: commands +PASS: gdb.base/default.exp: condition +PASS: gdb.base/default.exp: core-file +PASS: gdb.base/default.exp: delete "d" abbreviation +PASS: gdb.base/default.exp: delete +PASS: gdb.base/default.exp: define +PASS: gdb.base/default.exp: delete breakpoints +PASS: gdb.base/default.exp: delete display prompt +PASS: gdb.base/default.exp: detach +PASS: gdb.base/default.exp: directory prompt +PASS: gdb.base/default.exp: disable "dis" abbreviation +PASS: gdb.base/default.exp: disable "disa" abbreviation +PASS: gdb.base/default.exp: disable +PASS: gdb.base/default.exp: disable breakpoints +PASS: gdb.base/default.exp: disable display +PASS: gdb.base/default.exp: disassemble +PASS: gdb.base/default.exp: display +PASS: gdb.base/default.exp: do +PASS: gdb.base/default.exp: document +PASS: gdb.base/default.exp: down +PASS: gdb.base/default.exp: down-silently +PASS: gdb.base/default.exp: dump +PASS: gdb.base/default.exp: dump binary +PASS: gdb.base/default.exp: dump ihex +PASS: gdb.base/default.exp: dump memory +PASS: gdb.base/default.exp: dump srec +PASS: gdb.base/default.exp: dump tekhex +PASS: gdb.base/default.exp: dump value +PASS: gdb.base/default.exp: dump binary memory +PASS: gdb.base/default.exp: dump binary value +PASS: gdb.base/default.exp: dump ihex memory +PASS: gdb.base/default.exp: dump ihex value +PASS: gdb.base/default.exp: dump srec memory +PASS: gdb.base/default.exp: dump srec value +PASS: gdb.base/default.exp: dump tekhex memory +PASS: gdb.base/default.exp: dump tekhex value +PASS: gdb.base/default.exp: echo +PASS: gdb.base/default.exp: enable breakpoints delete +PASS: gdb.base/default.exp: enable breakpoints once +PASS: gdb.base/default.exp: enable breakpoints +PASS: gdb.base/default.exp: enable delete +PASS: gdb.base/default.exp: enable display +PASS: gdb.base/default.exp: enable once +PASS: gdb.base/default.exp: enable +PASS: gdb.base/default.exp: exec-file +PASS: gdb.base/default.exp: frame "f" abbreviation +PASS: gdb.base/default.exp: frame +PASS: gdb.base/default.exp: fg +PASS: gdb.base/default.exp: file +PASS: gdb.base/default.exp: finish +PASS: gdb.base/default.exp: forward-search +PASS: gdb.base/default.exp: gcore +PASS: gdb.base/default.exp: generate-core-file +PASS: gdb.base/default.exp: help "h" abbreviation +PASS: gdb.base/default.exp: help +PASS: gdb.base/default.exp: handle +PASS: gdb.base/default.exp: info "i" abbreviation +PASS: gdb.base/default.exp: info +PASS: gdb.base/default.exp: ignore +PASS: gdb.base/default.exp: info address +PASS: gdb.base/default.exp: info all-registers +PASS: gdb.base/default.exp: info args +PASS: gdb.base/default.exp: info bogus-gdb-command +PASS: gdb.base/default.exp: info breakpoints +PASS: gdb.base/default.exp: info copying +PASS: gdb.base/default.exp: info display +PASS: gdb.base/default.exp: info frame "f" abbreviation +PASS: gdb.base/default.exp: info frame +PASS: gdb.base/default.exp: info files +PASS: gdb.base/default.exp: info float +PASS: gdb.base/default.exp: info functions +PASS: gdb.base/default.exp: info locals +PASS: gdb.base/default.exp: info program +PASS: gdb.base/default.exp: info registers +PASS: gdb.base/default.exp: info stack "s" abbreviation +PASS: gdb.base/default.exp: info stack +PASS: gdb.base/default.exp: info set +PASS: gdb.base/default.exp: info symbol +PASS: gdb.base/default.exp: info source +PASS: gdb.base/default.exp: info sources +PASS: gdb.base/default.exp: info target +PASS: gdb.base/default.exp: info terminal +PASS: gdb.base/default.exp: info threads +PASS: gdb.base/default.exp: info types +PASS: gdb.base/default.exp: info variables +PASS: gdb.base/default.exp: info vector +PASS: gdb.base/default.exp: info warranty +PASS: gdb.base/default.exp: info watchpoints +PASS: gdb.base/default.exp: inspect +PASS: gdb.base/default.exp: jump +PASS: gdb.base/default.exp: kill +PASS: gdb.base/default.exp: list "l" abbreviation +PASS: gdb.base/default.exp: list +PASS: gdb.base/default.exp: load +PASS: gdb.base/default.exp: next "n" abbreviation +PASS: gdb.base/default.exp: next +PASS: gdb.base/default.exp: nexti "ni" abbreviation +PASS: gdb.base/default.exp: nexti +PASS: gdb.base/default.exp: output +PASS: gdb.base/default.exp: overlay +PASS: gdb.base/default.exp: overlay on +PASS: gdb.base/default.exp: overlay manual #1 +PASS: gdb.base/default.exp: overlay auto +PASS: gdb.base/default.exp: overlay off +PASS: gdb.base/default.exp: overlay list +PASS: gdb.base/default.exp: overlay map #1 +PASS: gdb.base/default.exp: overlay unmap #1 +PASS: gdb.base/default.exp: overlay manual #2 +PASS: gdb.base/default.exp: overlay map #2 +PASS: gdb.base/default.exp: overlay unmap #2 +PASS: gdb.base/default.exp: print "p" abbreviation +PASS: gdb.base/default.exp: print +PASS: gdb.base/default.exp: printf +PASS: gdb.base/default.exp: ptype +PASS: gdb.base/default.exp: pwd +PASS: gdb.base/default.exp: rbreak +PASS: gdb.base/default.exp: restore +PASS: gdb.base/default.exp: return +PASS: gdb.base/default.exp: reverse-search +PASS: gdb.base/default.exp: step "s" abbreviation #1 +PASS: gdb.base/default.exp: step #1 +PASS: gdb.base/default.exp: search +PASS: gdb.base/default.exp: section +PASS: gdb.base/default.exp: set annotate +PASS: gdb.base/default.exp: set args +PASS: gdb.base/default.exp: set check "c" abbreviation +PASS: gdb.base/default.exp: set check "ch" abbreviation +PASS: gdb.base/default.exp: set check "check" abbreviation +PASS: gdb.base/default.exp: set check range +PASS: gdb.base/default.exp: set check type +PASS: gdb.base/default.exp: set complaints +PASS: gdb.base/default.exp: set confirm +PASS: gdb.base/default.exp: set environment +PASS: gdb.base/default.exp: set height +PASS: gdb.base/default.exp: set history expansion +PASS: gdb.base/default.exp: set history filename +PASS: gdb.base/default.exp: set history save +PASS: gdb.base/default.exp: set history size +PASS: gdb.base/default.exp: set history +PASS: gdb.base/default.exp: set language +PASS: gdb.base/default.exp: set listsize +PASS: gdb.base/default.exp: set print "p" abbreviation +PASS: gdb.base/default.exp: set print "pr" abbreviation +PASS: gdb.base/default.exp: set print +PASS: gdb.base/default.exp: set print address +PASS: gdb.base/default.exp: set print array +PASS: gdb.base/default.exp: set print asm-demangle +PASS: gdb.base/default.exp: set print demangle +PASS: gdb.base/default.exp: set print elements +PASS: gdb.base/default.exp: set print object +PASS: gdb.base/default.exp: set print pretty +PASS: gdb.base/default.exp: set print sevenbit-strings +PASS: gdb.base/default.exp: set print union +PASS: gdb.base/default.exp: set print vtbl +PASS: gdb.base/default.exp: set radix +PASS: gdb.base/default.exp: set variable +PASS: gdb.base/default.exp: set verbose +PASS: gdb.base/default.exp: set width +PASS: gdb.base/default.exp: set write +PASS: gdb.base/default.exp: set +PASS: gdb.base/default.exp: shell echo Hi dad! +PASS: gdb.base/default.exp: show annotate +PASS: gdb.base/default.exp: show args +PASS: gdb.base/default.exp: show check "c" abbreviation +PASS: gdb.base/default.exp: show check "ch" abbreviation +PASS: gdb.base/default.exp: show check "check" abbreviation +PASS: gdb.base/default.exp: show check range +PASS: gdb.base/default.exp: show check type +PASS: gdb.base/default.exp: show commands +PASS: gdb.base/default.exp: show complaints +PASS: gdb.base/default.exp: show confirm +PASS: gdb.base/default.exp: show convenience +PASS: gdb.base/default.exp: show directories +PASS: gdb.base/default.exp: show editing +PASS: gdb.base/default.exp: show height +PASS: gdb.base/default.exp: show history expansion +PASS: gdb.base/default.exp: show history filename +PASS: gdb.base/default.exp: show history save +PASS: gdb.base/default.exp: show history size +PASS: gdb.base/default.exp: show history +PASS: gdb.base/default.exp: show language +PASS: gdb.base/default.exp: show listsize +PASS: gdb.base/default.exp: show p +PASS: gdb.base/default.exp: show pr +PASS: gdb.base/default.exp: show print +PASS: gdb.base/default.exp: show paths +PASS: gdb.base/default.exp: show print address +PASS: gdb.base/default.exp: show print array +PASS: gdb.base/default.exp: show print asm-demangle +PASS: gdb.base/default.exp: show print demangle +PASS: gdb.base/default.exp: show print elements +PASS: gdb.base/default.exp: show print object +PASS: gdb.base/default.exp: show print pretty +PASS: gdb.base/default.exp: show print sevenbit-strings +PASS: gdb.base/default.exp: show print union +PASS: gdb.base/default.exp: show print vtbl +PASS: gdb.base/default.exp: show prompt +PASS: gdb.base/default.exp: show radix +PASS: gdb.base/default.exp: show user +PASS: gdb.base/default.exp: show values +PASS: gdb.base/default.exp: show verbose +PASS: gdb.base/default.exp: show version +PASS: gdb.base/default.exp: show width +PASS: gdb.base/default.exp: show write +PASS: gdb.base/default.exp: show +PASS: gdb.base/default.exp: stepi "si" abbreviation +PASS: gdb.base/default.exp: stepi +PASS: gdb.base/default.exp: signal +PASS: gdb.base/default.exp: source +PASS: gdb.base/default.exp: step "s" abbreviation #2 +PASS: gdb.base/default.exp: step #2 +PASS: gdb.base/default.exp: symbol-file +PASS: gdb.base/default.exp: target child +PASS: gdb.base/default.exp: target procfs +PASS: gdb.base/default.exp: target core +PASS: gdb.base/default.exp: target exec +PASS: gdb.base/default.exp: target remote +PASS: gdb.base/default.exp: target +PASS: gdb.base/default.exp: tbreak +PASS: gdb.base/default.exp: thread +PASS: gdb.base/default.exp: thread apply +PASS: gdb.base/default.exp: thread find +PASS: gdb.base/default.exp: thread name +PASS: gdb.base/default.exp: tty +PASS: gdb.base/default.exp: until "u" abbreviation +PASS: gdb.base/default.exp: until +PASS: gdb.base/default.exp: undisplay prompt +PASS: gdb.base/default.exp: unset environment prompt +PASS: gdb.base/default.exp: unset +PASS: gdb.base/default.exp: up-silently +PASS: gdb.base/default.exp: watch +PASS: gdb.base/default.exp: whatis +PASS: gdb.base/default.exp: where +PASS: gdb.base/default.exp: x +Running ./gdb.base/define.exp ... +PASS: gdb.base/define.exp: define user command: nextwhere +PASS: gdb.base/define.exp: use user command: nextwhere +PASS: gdb.base/define.exp: define user command: nextwh +PASS: gdb.base/define.exp: redefine user command aborted: nextwhere +PASS: gdb.base/define.exp: redefine user command: nextwhere +PASS: gdb.base/define.exp: redocumenting builtin command disallowed +PASS: gdb.base/define.exp: document user command: nextwhere +PASS: gdb.base/define.exp: re-document user command: nextwhere +PASS: gdb.base/define.exp: help user command: nextwhere +PASS: gdb.base/define.exp: set up whitespace in help string +PASS: gdb.base/define.exp: preserve whitespace in help string +PASS: gdb.base/define.exp: define user command: ifnospace +PASS: gdb.base/define.exp: test ifnospace is parsed correctly +PASS: gdb.base/define.exp: define user command: whilenospace +PASS: gdb.base/define.exp: test whilenospace is parsed correctly +PASS: gdb.base/define.exp: define user command: user-bt +PASS: gdb.base/define.exp: define hook-stop command +PASS: gdb.base/define.exp: use hook-stop command +PASS: gdb.base/define.exp: define hook undefined command aborted: bar +PASS: gdb.base/define.exp: define hook undefined command: bar +PASS: gdb.base/define.exp: define target testsuite +PASS: gdb.base/define.exp: document target testsuite +PASS: gdb.base/define.exp: help target +PASS: gdb.base/define.exp: target testsuite +PASS: gdb.base/define.exp: show user target testsuite +PASS: gdb.base/define.exp: define target hook-testsuite +PASS: gdb.base/define.exp: define target hookpost-testsuite +PASS: gdb.base/define.exp: target testsuite with hooks +PASS: gdb.base/define.exp: set gdb_prompt +PASS: gdb.base/define.exp: reset gdb_prompt +Running ./gdb.base/del.exp ... +PASS: gdb.base/del.exp: Remove all breakpoints (del) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (del) +PASS: gdb.base/del.exp: Remove last breakpoint (del) +PASS: gdb.base/del.exp: info break after removing break on main (del) +PASS: gdb.base/del.exp: Remove all breakpoints (d) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (d) +PASS: gdb.base/del.exp: Remove last breakpoint (d) +PASS: gdb.base/del.exp: info break after removing break on main (d) +Running ./gdb.base/detach.exp ... +Running ./gdb.base/dfp-exprs.exp ... +PASS: gdb.base/dfp-exprs.exp: p 1.2df +PASS: gdb.base/dfp-exprs.exp: p -1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.234567df +PASS: gdb.base/dfp-exprs.exp: p -1.234567df +PASS: gdb.base/dfp-exprs.exp: p 1234567.df +PASS: gdb.base/dfp-exprs.exp: p -1234567.df +PASS: gdb.base/dfp-exprs.exp: p 1.2E1df +PASS: gdb.base/dfp-exprs.exp: p 1.2E10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E96df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd +PASS: gdb.base/dfp-exprs.exp: p -1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E384dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl +PASS: gdb.base/dfp-exprs.exp: p -1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E6144dl +PASS: gdb.base/dfp-exprs.exp: p 1.4df + 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df - 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df * 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df / 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4dd + 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd - 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd * 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd / 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dl + 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl - 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl * 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl / 1.2dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.df +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.dl + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 2.1df + 2.7dd +PASS: gdb.base/dfp-exprs.exp: p 2.1dd + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.6df + 2.7dl +PASS: gdb.base/dfp-exprs.exp: p 2.6dl + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.3dd + 2.2dl +PASS: gdb.base/dfp-exprs.exp: p 2.3dl + 2.2dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: p 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: p 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: ptype 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: ptype 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: ptype 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 2ll +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1.2f +PASS: gdb.base/dfp-exprs.exp: p !0.df +PASS: gdb.base/dfp-exprs.exp: p !0.dd +PASS: gdb.base/dfp-exprs.exp: p !0.dl +PASS: gdb.base/dfp-exprs.exp: p !0.5df +PASS: gdb.base/dfp-exprs.exp: p !0.5dd +PASS: gdb.base/dfp-exprs.exp: p !0.5dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p +1.2df +PASS: gdb.base/dfp-exprs.exp: p +1.2dd +PASS: gdb.base/dfp-exprs.exp: p +1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df > 1 +PASS: gdb.base/dfp-exprs.exp: p 1.2dl > 2 +PASS: gdb.base/dfp-exprs.exp: p 2 > 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 2 > 3.1dl +PASS: gdb.base/dfp-exprs.exp: p (float) -0.1df +PASS: gdb.base/dfp-exprs.exp: p (int) 8.3dd +PASS: gdb.base/dfp-exprs.exp: p (_Decimal64) 3.1 +PASS: gdb.base/dfp-exprs.exp: p (_Decimal128) 3.7df +PASS: gdb.base/dfp-exprs.exp: p (_Decimal32) 4 +Running ./gdb.base/dfp-test.exp ... +PASS: gdb.base/dfp-test.exp: get integer valueof "sizeof (long)" (4) +PASS: gdb.base/dfp-test.exp: next after initializing d32 +PASS: gdb.base/dfp-test.exp: d32 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d32 +PASS: gdb.base/dfp-test.exp: d32 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d32 +PASS: gdb.base/dfp-test.exp: d32 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d32 +PASS: gdb.base/dfp-test.exp: d32 is NaN +PASS: gdb.base/dfp-test.exp: p d32=123.45df +PASS: gdb.base/dfp-test.exp: p d32=12345.df +PASS: gdb.base/dfp-test.exp: p d32=12345.67df +PASS: gdb.base/dfp-test.exp: p d32=1234567.df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E0df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E10df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E+96df +PASS: gdb.base/dfp-test.exp: p d32=9.999999E96df +PASS: gdb.base/dfp-test.exp: p d32=1.0E-95df +PASS: gdb.base/dfp-test.exp: p d32=1.E-101df +PASS: gdb.base/dfp-test.exp: p d32=0.000001E-95df +PASS: gdb.base/dfp-test.exp: 1.2345678 is rounded to 1.234568 +PASS: gdb.base/dfp-test.exp: 1.0E-101 is rounded to 1E-101 +PASS: gdb.base/dfp-test.exp: 1.234567E+97 is Infinity +PASS: gdb.base/dfp-test.exp: 12345. is a valid number +PASS: gdb.base/dfp-test.exp: 12345 is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after initializing d64 +PASS: gdb.base/dfp-test.exp: d64 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d64 +PASS: gdb.base/dfp-test.exp: d64 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d64 +PASS: gdb.base/dfp-test.exp: d64 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d64 +PASS: gdb.base/dfp-test.exp: d64 is NaN +PASS: gdb.base/dfp-test.exp: p d64=123.45dd +PASS: gdb.base/dfp-test.exp: p d64=12345.dd +PASS: gdb.base/dfp-test.exp: p d64=12345.67dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E10dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E100dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E384dd +PASS: gdb.base/dfp-test.exp: p d64=9.999999999999999E384dd +PASS: gdb.base/dfp-test.exp: p d64=1.E-383dd +PASS: gdb.base/dfp-test.exp: p d64=1.E-398dd +PASS: gdb.base/dfp-test.exp: p d64=0.000000000000001E-383dd +PASS: gdb.base/dfp-test.exp: 1.2345678901234567 is rounded to 1.234567890123457 +PASS: gdb.base/dfp-test.exp: d64=9.9999999999999999E384 is Infinity +PASS: gdb.base/dfp-test.exp: d64=1.234567890123456E385 is Infinity +PASS: gdb.base/dfp-test.exp: 12345dd is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after initializing d128 +PASS: gdb.base/dfp-test.exp: d128 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: p d128=123.45dl +PASS: gdb.base/dfp-test.exp: p d128=12345.dl +PASS: gdb.base/dfp-test.exp: p d128=12345.67dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E10dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E100dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E1000dl +PASS: gdb.base/dfp-test.exp: p d128=9.999999999999999999999999999999999E6144dl +PASS: gdb.base/dfp-test.exp: p d128=1.E-6143dl +PASS: gdb.base/dfp-test.exp: p d128=1.E-6176dl +PASS: gdb.base/dfp-test.exp: p d128=0.000000000000000000000000000000001E-6143dl +PASS: gdb.base/dfp-test.exp: 1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234 +PASS: gdb.base/dfp-test.exp: d128=1.234567890123456E6145 is Infinity +PASS: gdb.base/dfp-test.exp: 12345dl is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d128 +PASS: gdb.base/dfp-test.exp: d128 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d128 +PASS: gdb.base/dfp-test.exp: d128 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d128 +PASS: gdb.base/dfp-test.exp: d128 is NaN +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_32 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_32 +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_64 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_64 +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_128 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_128 +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal32 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal64 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal128 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with mixed decimal float arguments TEST. +PASS: gdb.base/dfp-test.exp: Call function with mixed decimal float arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many mixed decimal float arguments. +PASS: gdb.base/dfp-test.exp: continue to breakpoint: Setting a decimal struct +PASS: gdb.base/dfp-test.exp: print ds.dec32 +PASS: gdb.base/dfp-test.exp: print ds.dec64 +PASS: gdb.base/dfp-test.exp: print ds.dec128 +PASS: gdb.base/dfp-test.exp: print d32 + ds.dec32 +PASS: gdb.base/dfp-test.exp: print d64 + ds.dec64 +PASS: gdb.base/dfp-test.exp: print d128 + ds.dec128 +PASS: gdb.base/dfp-test.exp: ptype d64 + ds.dec32 +PASS: gdb.base/dfp-test.exp: ptype d128 + ds.dec32 +PASS: gdb.base/dfp-test.exp: ptype d128 + ds.dec64 +PASS: gdb.base/dfp-test.exp: p d32 + 1 +PASS: gdb.base/dfp-test.exp: p 2 + d64 +PASS: gdb.base/dfp-test.exp: p ds.int4 + d128 +PASS: gdb.base/dfp-test.exp: ptype d32 + 1 +PASS: gdb.base/dfp-test.exp: ptype ds.int4 + d128 +PASS: gdb.base/dfp-test.exp: p !d32 +PASS: gdb.base/dfp-test.exp: p !d64 +PASS: gdb.base/dfp-test.exp: p !d128 +PASS: gdb.base/dfp-test.exp: p +d32 +PASS: gdb.base/dfp-test.exp: p +d64 +PASS: gdb.base/dfp-test.exp: p +d128 +PASS: gdb.base/dfp-test.exp: p d64 == d128 +PASS: gdb.base/dfp-test.exp: p d128 == ds.dec32 +PASS: gdb.base/dfp-test.exp: p d128 == d32 +PASS: gdb.base/dfp-test.exp: p ds.dec32 == ds.dec64 +PASS: gdb.base/dfp-test.exp: p d32 < ds.dec32 +PASS: gdb.base/dfp-test.exp: p d64 < ds.dec64 +PASS: gdb.base/dfp-test.exp: p d128 < ds.dec128 +PASS: gdb.base/dfp-test.exp: p ds.dec32 < d32 +PASS: gdb.base/dfp-test.exp: p d64 > ds.dec64 +PASS: gdb.base/dfp-test.exp: p ds.dec128 > d128 +PASS: gdb.base/dfp-test.exp: p d32 < ds.int4 +PASS: gdb.base/dfp-test.exp: p ds.int4 > d32 +PASS: gdb.base/dfp-test.exp: p ds.dec32 < ds.int4 +PASS: gdb.base/dfp-test.exp: p ds.int4 > ds.dec64 +PASS: gdb.base/dfp-test.exp: p ds.dec128 > ds.int4 +PASS: gdb.base/dfp-test.exp: p d64 + ds.float4 +PASS: gdb.base/dfp-test.exp: p ds.double8 + d128 +PASS: gdb.base/dfp-test.exp: print ds.dec32=d32 +PASS: gdb.base/dfp-test.exp: print ds.dec64=d64 +PASS: gdb.base/dfp-test.exp: print ds.dec128=d128 +PASS: gdb.base/dfp-test.exp: print ds.dec32 = -d32 +PASS: gdb.base/dfp-test.exp: print ds.dec64 = -d64 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = -d128 +PASS: gdb.base/dfp-test.exp: print ds.double8 = ds.dec64 +PASS: gdb.base/dfp-test.exp: print ds.dec64 = ds.float4 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = -ds.double8 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = ds.dec32 +PASS: gdb.base/dfp-test.exp: print ds.dec32 = ds.int4 +PASS: gdb.base/dfp-test.exp: print ds.int4 = 7.3dl +Running ./gdb.base/disabled-location.exp ... +PASS: gdb.base/disabled-location.exp: setting breakpoint on function +PASS: gdb.base/disabled-location.exp: disable location +PASS: gdb.base/disabled-location.exp: step doesn't trip on disabled location +Running ./gdb.base/disasm-end-cu.exp ... +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&main" +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&dummy_3" +PASS: gdb.base/disasm-end-cu.exp: disassemble command returned some output +Running ./gdb.base/display.exp ... +PASS: gdb.base/display.exp: break do_loops +PASS: gdb.base/display.exp: get to do_loops +PASS: gdb.base/display.exp: set watch +PASS: gdb.base/display.exp: break loop end +PASS: gdb.base/display.exp: inf disp +PASS: gdb.base/display.exp: display i +PASS: gdb.base/display.exp: display j +PASS: gdb.base/display.exp: display &k +PASS: gdb.base/display.exp: display/f f +PASS: gdb.base/display.exp: display/s &sum +PASS: gdb.base/display.exp: first disp +PASS: gdb.base/display.exp: second disp +PASS: gdb.base/display.exp: catch err +PASS: gdb.base/display.exp: disab disp 1 +PASS: gdb.base/display.exp: disab disp 2 +PASS: gdb.base/display.exp: re-enab +PASS: gdb.base/display.exp: re-enab of enab +PASS: gdb.base/display.exp: undisp +PASS: gdb.base/display.exp: info disp +PASS: gdb.base/display.exp: next hit +PASS: gdb.base/display.exp: undisp all +PASS: gdb.base/display.exp: disp *p_i +PASS: gdb.base/display.exp: p p_i = 0x0 +PASS: gdb.base/display.exp: display bad address +PASS: gdb.base/display.exp: p p_i = &i +PASS: gdb.base/display.exp: display good address +PASS: gdb.base/display.exp: undisp all again +PASS: gdb.base/display.exp: disab 3 +PASS: gdb.base/display.exp: watch off +PASS: gdb.base/display.exp: finish +PASS: gdb.base/display.exp: step +PASS: gdb.base/display.exp: tbreak in do_vars +PASS: gdb.base/display.exp: cont +PASS: gdb.base/display.exp: printf +PASS: gdb.base/display.exp: printf %d +PASS: gdb.base/display.exp: printf "%d +PASS: gdb.base/display.exp: printf "%d%d",i +PASS: gdb.base/display.exp: printf "\\!\a\f\r\t\v\b\n" +PASS: gdb.base/display.exp: re-set term +PASS: gdb.base/display.exp: printf "\w" +PASS: gdb.base/display.exp: printf "%d" j +PASS: gdb.base/display.exp: printf "%p\n", 0 +PASS: gdb.base/display.exp: printf "%p\n", 1 +PASS: gdb.base/display.exp: print/z j +PASS: gdb.base/display.exp: debug test output 1 +PASS: gdb.base/display.exp: debug test output 1a +PASS: gdb.base/display.exp: debug test output 2 +PASS: gdb.base/display.exp: debug test output 2a +PASS: gdb.base/display.exp: debug test output 3 +PASS: gdb.base/display.exp: x/0 j +PASS: gdb.base/display.exp: print/0 j +PASS: gdb.base/display.exp: ignored s +PASS: gdb.base/display.exp: no i +PASS: gdb.base/display.exp: print/a &sum +PASS: gdb.base/display.exp: print/a main+4 +PASS: gdb.base/display.exp: print/a $pc +PASS: gdb.base/display.exp: print/a &&j +Running ./gdb.base/disp-step-syscall.exp ... +PASS: gdb.base/disp-step-syscall.exp: fork: delete break 1 +PASS: gdb.base/disp-step-syscall.exp: fork: break marker +PASS: gdb.base/disp-step-syscall.exp: fork: set displaced-stepping off +PASS: gdb.base/disp-step-syscall.exp: fork: break fork +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (1st time) +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (2nd time) +PASS: gdb.base/disp-step-syscall.exp: fork: display/i $pc +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: stepi fork insn +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (3rd time) +PASS: gdb.base/disp-step-syscall.exp: fork: break on syscall insns +PASS: gdb.base/disp-step-syscall.exp: fork: delete break fork +PASS: gdb.base/disp-step-syscall.exp: fork: continue to syscall insn fork +PASS: gdb.base/disp-step-syscall.exp: fork: set displaced-stepping on +PASS: gdb.base/disp-step-syscall.exp: fork: single step over fork +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: single step over fork final pc +PASS: gdb.base/disp-step-syscall.exp: fork: delete break fork insn +PASS: gdb.base/disp-step-syscall.exp: fork: continue to marker (fork) +PASS: gdb.base/disp-step-syscall.exp: vfork: delete break 1 +PASS: gdb.base/disp-step-syscall.exp: vfork: break marker +PASS: gdb.base/disp-step-syscall.exp: vfork: set displaced-stepping off +PASS: gdb.base/disp-step-syscall.exp: vfork: break vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (1st time) +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (2nd time) +PASS: gdb.base/disp-step-syscall.exp: vfork: display/i $pc +PASS: gdb.base/disp-step-syscall.exp: vfork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: vfork: stepi vfork insn +PASS: gdb.base/disp-step-syscall.exp: vfork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (3rd time) +PASS: gdb.base/disp-step-syscall.exp: vfork: break on syscall insns +PASS: gdb.base/disp-step-syscall.exp: vfork: delete break vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to syscall insn vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: set displaced-stepping on +KPASS: gdb.base/disp-step-syscall.exp: vfork: single step over vfork (PRMS server/13796) +FAIL: gdb.base/disp-step-syscall.exp: vfork: get hexadecimal valueof "$pc" (timeout) +FAIL: gdb.base/disp-step-syscall.exp: vfork: single step over vfork final pc +FAIL: gdb.base/disp-step-syscall.exp: vfork: delete break vfork insn +FAIL: gdb.base/disp-step-syscall.exp: vfork: continue to marker (vfork) (the program is no longer running) +Running ./gdb.base/dmsym.exp ... +PASS: gdb.base/dmsym.exp: set lang ada +PASS: gdb.base/dmsym.exp: break pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: info line pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: set lang auto +PASS: gdb.base/dmsym.exp: Run until breakpoint at BREAK +PASS: gdb.base/dmsym.exp: continue +PASS: gdb.base/dmsym.exp: print val +Running ./gdb.base/dprintf.exp ... +PASS: gdb.base/dprintf.exp: dprintf +PASS: gdb.base/dprintf.exp: dprintf foo +PASS: gdb.base/dprintf.exp: dprintf 29 +PASS: gdb.base/dprintf.exp: dprintf foo,"At foo entry\n" +PASS: gdb.base/dprintf.exp: ignore $bpnum 1 +PASS: gdb.base/dprintf.exp: dprintf 26,"arg=%d, g=%d\n", arg, g +PASS: gdb.base/dprintf.exp: dprintf info 1 +PASS: gdb.base/dprintf.exp: break 27 +PASS: gdb.base/dprintf.exp: 1st dprintf, gdb +PASS: gdb.base/dprintf.exp: 2nd dprintf, gdb +PASS: gdb.base/dprintf.exp: Set dprintf style to agent - can do +PASS: gdb.base/dprintf.exp: 1st dprintf, agent +PASS: gdb.base/dprintf.exp: 2nd dprintf, agent +PASS: gdb.base/dprintf.exp: dprintf info 2 +PASS: gdb.base/dprintf.exp: Set dprintf style to an unrecognized type +Running ./gdb.base/dprintf-next.exp ... +PASS: gdb.base/dprintf-next.exp: dprintf 24, "%d\n", x +PASS: gdb.base/dprintf-next.exp: next 1 +PASS: gdb.base/dprintf-next.exp: next 2 +Running ./gdb.base/dprintf-non-stop.exp ... +UNSUPPORTED: gdb.base/dprintf-non-stop.exp: Testing dprintf with remote/non-stop is not supported. +Running ./gdb.base/dprintf-pending.exp ... +PASS: gdb.base/dprintf-pending.exp: without format: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: without format: resolved dprintf fails to be re-set +PASS: gdb.base/dprintf-pending.exp: without symbols: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: without symbols: single pending dprintf info +PASS: gdb.base/dprintf-pending.exp: without symbols: run to resolved dprintf +PASS: gdb.base/dprintf-pending.exp: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: single pending dprintf info +PASS: gdb.base/dprintf-pending.exp: run to resolved dprintf +Running ./gdb.base/dump.exp ... +PASS: gdb.base/dump.exp: inaccessible memory is reported +PASS: gdb.base/dump.exp: endianness: little +PASS: gdb.base/dump.exp: dump array as value, default +PASS: gdb.base/dump.exp: dump struct as value, default +PASS: gdb.base/dump.exp: dump array as value, binary +PASS: gdb.base/dump.exp: dump struct as value, binary +PASS: gdb.base/dump.exp: dump array as value, srec +PASS: gdb.base/dump.exp: dump struct as value, srec +PASS: gdb.base/dump.exp: dump array as value, intel hex +PASS: gdb.base/dump.exp: dump struct as value, intel hex +PASS: gdb.base/dump.exp: dump array as value, tekhex +PASS: gdb.base/dump.exp: dump struct as value, tekhex +PASS: gdb.base/dump.exp: capture /x &intarray[0] +PASS: gdb.base/dump.exp: capture /x &intarray[32] +PASS: gdb.base/dump.exp: capture /x &intstruct +PASS: gdb.base/dump.exp: capture /x &intstruct + 1 +PASS: gdb.base/dump.exp: capture intarray +PASS: gdb.base/dump.exp: capture intstruct +PASS: gdb.base/dump.exp: capture type of pointer &intarray +PASS: gdb.base/dump.exp: capture type of pointer &intstruct +PASS: gdb.base/dump.exp: dump array as memory, default +PASS: gdb.base/dump.exp: dump struct as memory, default +PASS: gdb.base/dump.exp: dump array as memory, binary +PASS: gdb.base/dump.exp: dump struct as memory, binary +PASS: gdb.base/dump.exp: dump array as memory, srec +PASS: gdb.base/dump.exp: dump struct as memory, srec +PASS: gdb.base/dump.exp: dump array as memory, ihex +PASS: gdb.base/dump.exp: dump struct as memory, ihex +PASS: gdb.base/dump.exp: dump array as memory, tekhex +PASS: gdb.base/dump.exp: dump struct as memory, tekhex +PASS: gdb.base/dump.exp: dump array as mem, srec, expressions +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, srec; file restored ok +PASS: gdb.base/dump.exp: array as value, srec; capture intarray +PASS: gdb.base/dump.exp: array as value, srec; value restored ok +PASS: gdb.base/dump.exp: struct as value, srec; file restored ok +PASS: gdb.base/dump.exp: struct as value, srec; capture intstruct +PASS: gdb.base/dump.exp: struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: zero all +PASS: gdb.base/dump.exp: array as memory, srec; file restored ok +PASS: gdb.base/dump.exp: array as memory, srec; capture intarray +PASS: gdb.base/dump.exp: array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; file restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, ihex; file restored ok +PASS: gdb.base/dump.exp: array as value, ihex; capture intarray +PASS: gdb.base/dump.exp: array as value, ihex; value restored ok +PASS: gdb.base/dump.exp: struct as value, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as value, ihex; capture intstruct +PASS: gdb.base/dump.exp: struct as value, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: array as memory, ihex; capture intarray +PASS: gdb.base/dump.exp: array as memory, ihex; value restored ok +PASS: gdb.base/dump.exp: struct as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, ihex; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as value, tekhex; capture intarray +PASS: gdb.base/dump.exp: array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; capture intstruct +PASS: gdb.base/dump.exp: struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as memory, tekhex; capture intarray +PASS: gdb.base/dump.exp: array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, binary; file restored ok +PASS: gdb.base/dump.exp: array as value, binary; capture intarray +PASS: gdb.base/dump.exp: array as value, binary; value restored ok +PASS: gdb.base/dump.exp: struct as value, binary; file restored ok +PASS: gdb.base/dump.exp: struct as value, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as value, binary; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, binary; file restored ok +PASS: gdb.base/dump.exp: array as memory, binary; capture intarray +PASS: gdb.base/dump.exp: array as memory, binary; value restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; file restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray2[0] +PASS: gdb.base/dump.exp: capture /x &intstruct2 +PASS: gdb.base/dump.exp: capture (char *) &intarray2 - (char *) &intarray +PASS: gdb.base/dump.exp: capture (char *) &intstruct2 - (char *) &intstruct +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, srec; file restored ok +PASS: gdb.base/dump.exp: array copy, srec; capture intarray2 +PASS: gdb.base/dump.exp: array copy, srec; value restored ok +PASS: gdb.base/dump.exp: struct copy, srec; file restored ok +PASS: gdb.base/dump.exp: struct copy, srec; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, ihex; file restored ok +PASS: gdb.base/dump.exp: array copy, ihex; capture intarray2 +PASS: gdb.base/dump.exp: array copy, ihex; value restored ok +PASS: gdb.base/dump.exp: struct copy, ihex; file restored ok +PASS: gdb.base/dump.exp: struct copy, ihex; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: array copy, tekhex; capture intarray2 +PASS: gdb.base/dump.exp: array copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, binary; file restored ok +PASS: gdb.base/dump.exp: array copy, binary; capture intarray2 +PASS: gdb.base/dump.exp: array copy, binary; value restored ok +PASS: gdb.base/dump.exp: struct copy, binary; file restored ok +PASS: gdb.base/dump.exp: struct copy, binary; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray[3] +PASS: gdb.base/dump.exp: capture /x &intarray[4] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[3] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[4] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, srec; file restored ok +PASS: gdb.base/dump.exp: array partial, srec; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, srec; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 1 +PASS: gdb.base/dump.exp: element 4 not changed - 1 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, ihex; file restored ok +PASS: gdb.base/dump.exp: array partial, ihex; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, ihex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 2 +PASS: gdb.base/dump.exp: element 4 not changed - 2 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, tekhex; file restored ok +PASS: gdb.base/dump.exp: array partial, tekhex; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, tekhex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 3 +PASS: gdb.base/dump.exp: element 4 not changed - 3 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, binary; file restored ok +PASS: gdb.base/dump.exp: array partial, binary; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, binary; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 4 +PASS: gdb.base/dump.exp: element 4 not changed - 4 +PASS: gdb.base/dump.exp: array partial with expressions; file restored ok +PASS: gdb.base/dump.exp: array partial with expressions; capture intarray2[3] +PASS: gdb.base/dump.exp: array partial with expressions; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed, == 4 +PASS: gdb.base/dump.exp: element 4 not changed, == 4 +PASS: gdb.base/dump.exp: setting little endianness +PASS: gdb.base/dump.exp: file binfile; capture intarray +PASS: gdb.base/dump.exp: start with intarray un-initialized +PASS: gdb.base/dump.exp: file binfile; capture intstruct +PASS: gdb.base/dump.exp: start with intstruct un-initialized +PASS: gdb.base/dump.exp: reload array as value, srec; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, srec; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, srec; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, srec; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as memory, srec; value restored ok +PASS: gdb.base/dump.exp: reload array as value, intel hex; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as value, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, intel hex; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as value, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, intel hex; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as memory, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, intel hex; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as memory, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload array as value, tekhex; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, tekhex; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, tekhex; capture * (int (*)[32]) 0x55557040 +PASS: gdb.base/dump.exp: reload array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, tekhex; capture * (struct teststruct *) 0x55557140 +PASS: gdb.base/dump.exp: reload struct as memory, tekhex; value restored ok +Running ./gdb.base/duplicate-bp.exp ... +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete #2, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable #1, delete #2, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable #2, delete #1, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable #1, delete #3, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable #3, delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable #2, delete #3, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable #3, delete #2, stop at #1 +Running ./gdb.base/dup-sect.exp ... +PASS: gdb.base/dup-sect.exp: rename section +PASS: gdb.base/dup-sect.exp: split +PASS: gdb.base/dup-sect.exp: strip +PASS: gdb.base/dup-sect.exp: var1 after strip +PASS: gdb.base/dup-sect.exp: var2 after strip +Running ./gdb.base/echo.exp ... +PASS: gdb.base/echo.exp: Echo test +Running ./gdb.base/empty_exe.exp ... +PASS: gdb.base/empty_exe.exp: file '' +PASS: gdb.base/empty_exe.exp: print 1 +Running ./gdb.base/ena-dis-br.exp ... +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: enable break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +PASS: gdb.base/ena-dis-br.exp: continue to break marker1 +PASS: gdb.base/ena-dis-br.exp: delete break marker1 +PASS: gdb.base/ena-dis-br.exp: break marker2 +PASS: gdb.base/ena-dis-br.exp: enable once break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: break marker3 +PASS: gdb.base/ena-dis-br.exp: enable del break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: break marker4 +PASS: gdb.base/ena-dis-br.exp: disable break marker4 +PASS: gdb.base/ena-dis-br.exp: info break marker4 +PASS: gdb.base/ena-dis-br.exp: break 113 +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break with count +PASS: gdb.base/ena-dis-br.exp: continue from enable count, first time +PASS: gdb.base/ena-dis-br.exp: continue from enable count, second time +PASS: gdb.base/ena-dis-br.exp: continue through enable count, now disabled +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore non-existent break +PASS: gdb.base/ena-dis-br.exp: ignore break with missing ignore count +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 -1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 0 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: info ignored break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue to break marker1, 2nd time +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: enable del break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored & auto-deleted break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue to ignored & auto-deleted break marker1 +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored & disabled break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: info ignored & disabled break marker1 +PASS: gdb.base/ena-dis-br.exp: prepare to continue with ignore count +PASS: gdb.base/ena-dis-br.exp: continue with ignore count +PASS: gdb.base/ena-dis-br.exp: step +PASS: gdb.base/ena-dis-br.exp: continue with ignore count, not stopped at bpt +Running ./gdb.base/ending-run.exp ... +PASS: gdb.base/ending-run.exp: bpt at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:14, one +PASS: gdb.base/ending-run.exp: b ending-run.c:31 +PASS: gdb.base/ending-run.exp: run +PASS: gdb.base/ending-run.exp: clear worked +PASS: gdb.base/ending-run.exp: cleared bp at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:1 +PASS: gdb.base/ending-run.exp: b ending-run.c:14, two +PASS: gdb.base/ending-run.exp: Cleared 2 by line +PASS: gdb.base/ending-run.exp: b ending-run.c:14 +PASS: gdb.base/ending-run.exp: Breakpoint 7 at *ending-run.c:14 +PASS: gdb.base/ending-run.exp: Clear 2 by default +PASS: gdb.base/ending-run.exp: all set to continue +PASS: gdb.base/ending-run.exp: cont +PASS: gdb.base/ending-run.exp: step out of main +Running ./gdb.base/enum_cond.exp ... +PASS: gdb.base/enum_cond.exp: break call_me if param.e == 1 +PASS: gdb.base/enum_cond.exp: continue to conditional breakpoint in call_me +Running ./gdb.base/enumval.exp ... +PASS: gdb.base/enumval.exp: print e +PASS: gdb.base/enumval.exp: print f +PASS: gdb.base/enumval.exp: print J +PASS: gdb.base/enumval.exp: print K +Running ./gdb.base/environ.exp ... +Running ./gdb.base/eu-strip-infcall.exp ... +PASS: gdb.base/eu-strip-infcall.exp: infcall +Running ./gdb.base/eval.exp ... +PASS: gdb.base/eval.exp: Initialize $a. +PASS: gdb.base/eval.exp: First eval. +PASS: gdb.base/eval.exp: Second eval. +Running ./gdb.base/eval-skip.exp ... +PASS: gdb.base/eval-skip.exp: set variable x=14 +PASS: gdb.base/eval-skip.exp: set variable y=2 +PASS: gdb.base/eval-skip.exp: set variable z=2 +PASS: gdb.base/eval-skip.exp: set variable w=3 +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x-y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x*y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x/y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x%y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x||y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x|y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x^y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x < y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x <= y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x==y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x!=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x<<31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>>31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (!x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (~x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (-x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x++)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (++x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x--)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (--x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+=7)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x=y)) +Running ./gdb.base/exe-lock.exp ... +PASS: gdb.base/exe-lock.exp: continue until exit +Running ./gdb.base/expand-psymtabs.exp ... +PASS: gdb.base/expand-psymtabs.exp: Expand psymtabs +Running ./gdb.base/exprs.exp ... +PASS: gdb.base/exprs.exp: print char == (setup) +PASS: gdb.base/exprs.exp: print char == (print v_char == 0) +PASS: gdb.base/exprs.exp: print char == (print v_char == 127) +PASS: gdb.base/exprs.exp: print char != (setup) +PASS: gdb.base/exprs.exp: print char != (print v_char != 0) +PASS: gdb.base/exprs.exp: print char != (print v_char != 127) +PASS: gdb.base/exprs.exp: print char < (setup) +PASS: gdb.base/exprs.exp: print char < (print v_char < 0) +PASS: gdb.base/exprs.exp: print char < (print v_char < 127) +PASS: gdb.base/exprs.exp: print char > (setup) +PASS: gdb.base/exprs.exp: print char > (print v_char > 0) +PASS: gdb.base/exprs.exp: print char > (print v_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (setup) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 127) +PASS: gdb.base/exprs.exp: print signed char != (setup) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 127) +PASS: gdb.base/exprs.exp: print signed char < (setup) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (setup) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == -1) +PASS: gdb.base/exprs.exp: print signed char != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != -1) +PASS: gdb.base/exprs.exp: print signed char < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 127) +PASS: gdb.base/exprs.exp: print unsigned char != (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 127) +PASS: gdb.base/exprs.exp: print unsigned char < (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == ~0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != ~0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print signed short == (setup) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short != (setup) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short < (setup) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (setup) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == -1) +PASS: gdb.base/exprs.exp: print signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != -1) +PASS: gdb.base/exprs.exp: print signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short != (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short < (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == -1) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != -1) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short != (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short < (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print sizeof (v_unsigned_short) < sizeof (~0) && v_unsigned_short == ~0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (setup) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int != (setup) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int < (setup) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (setup) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == -1) +PASS: gdb.base/exprs.exp: print signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != -1) +PASS: gdb.base/exprs.exp: print signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int != (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int < (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == -1) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != -1) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int != (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int < (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == ~0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (setup) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long != (setup) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long < (setup) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (setup) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == -1) +PASS: gdb.base/exprs.exp: print signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != -1) +PASS: gdb.base/exprs.exp: print signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long != (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long < (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == -1) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != -1) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long != (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long < (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == ~0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (print (void*)v_signed_char) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (print (void*)v_signed_short) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (print (void*)v_signed_int) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (print (void*)v_signed_long) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (print (void*)v_unsigned_char) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (print (void*)v_unsigned_short) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (print (void*)v_unsigned_int) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (print (void*)v_unsigned_long) +PASS: gdb.base/exprs.exp: sizeof (long long) > sizeof (long) (true) +PASS: gdb.base/exprs.exp: truncate (void*) 0x00000000ffffffff + 1 +PASS: gdb.base/exprs.exp: truncate (void*) 0xffffffff00000000 - 1 +PASS: gdb.base/exprs.exp: \$[0-9]* = "xy" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = "xyz" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: set output-radix 8 +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = 0 (setup) +PASS: gdb.base/exprs.exp: set output-radix 10 +PASS: gdb.base/exprs.exp: set variable v_int = 1 +PASS: gdb.base/exprs.exp: print v_int++ +PASS: gdb.base/exprs.exp: print ++v_int +PASS: gdb.base/exprs.exp: print v_int-- +PASS: gdb.base/exprs.exp: print --v_int +PASS: gdb.base/exprs.exp: print v_int++ = 5 +PASS: gdb.base/exprs.exp: print v_int-- = 5 +PASS: gdb.base/exprs.exp: print v_int_array_init +PASS: gdb.base/exprs.exp: print *v_int_array_init@1 +PASS: gdb.base/exprs.exp: print *v_int_array_init@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@1 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[1]@1 +PASS: gdb.base/exprs.exp: set variable v_short_array[0] = 42 +PASS: gdb.base/exprs.exp: print {short} v_short_array +PASS: gdb.base/exprs.exp: print (void) v_int_pointer +PASS: gdb.base/exprs.exp: print & (void) v_char +Running ./gdb.base/fileio.exp ... +Running ./gdb.base/find.exp ... +PASS: gdb.base/find.exp: breakpoint function in file +PASS: gdb.base/find.exp: run until function breakpoint +PASS: gdb.base/find.exp: find string pattern +PASS: gdb.base/find.exp: pattern not found at end of range +PASS: gdb.base/find.exp: pattern found at end of range +PASS: gdb.base/find.exp: max-count +PASS: gdb.base/find.exp: $_ +PASS: gdb.base/find.exp: $numfound +PASS: gdb.base/find.exp: size,max-count, /1b +PASS: gdb.base/find.exp: size,max-count, /b1 +PASS: gdb.base/find.exp: size,max-count, /b/1 +PASS: gdb.base/find.exp: size,max-count, /1/b +PASS: gdb.base/find.exp: find byte pattern with end address +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find mixed-sized pattern +PASS: gdb.base/find.exp: search spanning large range +PASS: gdb.base/find.exp: find int64_search_buf, +64/8*100, int64_search_buf +Running ./gdb.base/find-unmapped.exp ... +Running ./gdb.base/finish.exp ... +PASS: gdb.base/finish.exp: set break on void_func +PASS: gdb.base/finish.exp: continue to void_func +PASS: gdb.base/finish.exp: finish from void_func +PASS: gdb.base/finish.exp: set break on char_func +PASS: gdb.base/finish.exp: continue to char_func +PASS: gdb.base/finish.exp: finish from char_func +PASS: gdb.base/finish.exp: set break on short_func +PASS: gdb.base/finish.exp: continue to short_func +PASS: gdb.base/finish.exp: finish from short_func +PASS: gdb.base/finish.exp: set break on int_func +PASS: gdb.base/finish.exp: continue to int_func +PASS: gdb.base/finish.exp: finish from int_func +PASS: gdb.base/finish.exp: set break on long_func +PASS: gdb.base/finish.exp: continue to long_func +PASS: gdb.base/finish.exp: finish from long_func +PASS: gdb.base/finish.exp: set break on long_long_func +PASS: gdb.base/finish.exp: continue to long_long_func +PASS: gdb.base/finish.exp: finish from long_long_func +PASS: gdb.base/finish.exp: set break on float_func +PASS: gdb.base/finish.exp: continue to float_func +PASS: gdb.base/finish.exp: finish from float_func +PASS: gdb.base/finish.exp: set break on double_func +PASS: gdb.base/finish.exp: continue to double_func +PASS: gdb.base/finish.exp: finish from double_func +PASS: gdb.base/finish.exp: Testing the "fin" abbreviation for "finish" +Running ./gdb.base/fixsection.exp ... +PASS: gdb.base/fixsection.exp: breakpoint at static_fun +Running ./gdb.base/float.exp ... +PASS: gdb.base/float.exp: info float +PASS: gdb.base/float.exp: step +PASS: gdb.base/float.exp: finish +Running ./gdb.base/foll-exec.exp ... +Running ./gdb.base/foll-fork.exp ... +Running ./gdb.base/foll-vfork.exp ... +Running ./gdb.base/fortran-sym-case.exp ... +PASS: gdb.base/fortran-sym-case.exp: set language fortran +PASS: gdb.base/fortran-sym-case.exp: frame +Running ./gdb.base/frame-args.exp ... +PASS: gdb.base/frame-args.exp: set print frame-arguments all +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to all +PASS: gdb.base/frame-args.exp: set print frame-arguments scalars +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to scalars +PASS: gdb.base/frame-args.exp: set print frame-arguments none +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to none +Running ./gdb.base/freebpcmd.exp ... +PASS: gdb.base/freebpcmd.exp: set breakpoint +PASS: gdb.base/freebpcmd.exp: send breakpoint commands +PASS: gdb.base/freebpcmd.exp: run program with breakpoint commands +Running ./gdb.base/fullname.exp ... +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint at main - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint at main - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built other +PASS: gdb.base/fullname.exp: set breakpoint at main - built other +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built other +Running ./gdb.base/fullpath-expand.exp ... +PASS: gdb.base/fullpath-expand.exp: rbreak XXX/fullpath-expand-func.c:func +PASS: gdb.base/fullpath-expand.exp: list func +PASS: gdb.base/fullpath-expand.exp: info source +Running ./gdb.base/funcargs.exp ... +PASS: gdb.base/funcargs.exp: set print frame-arguments all +PASS: gdb.base/funcargs.exp: run to call0a +PASS: gdb.base/funcargs.exp: print c after run to call0a +PASS: gdb.base/funcargs.exp: print s after run to call0a +PASS: gdb.base/funcargs.exp: print i after run to call0a +PASS: gdb.base/funcargs.exp: print l after run to call0a +PASS: gdb.base/funcargs.exp: continue to call0b +PASS: gdb.base/funcargs.exp: continue to call0c +PASS: gdb.base/funcargs.exp: continue to call0d +PASS: gdb.base/funcargs.exp: continue to call0e +PASS: gdb.base/funcargs.exp: run to call1a +PASS: gdb.base/funcargs.exp: print uc +PASS: gdb.base/funcargs.exp: print us +PASS: gdb.base/funcargs.exp: print ui +PASS: gdb.base/funcargs.exp: print ul +PASS: gdb.base/funcargs.exp: continue to call1b +PASS: gdb.base/funcargs.exp: continue to call1c +PASS: gdb.base/funcargs.exp: continue to call1d +PASS: gdb.base/funcargs.exp: continue to call1e +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: print c after run to call2a +PASS: gdb.base/funcargs.exp: print f1 after run to call2a +PASS: gdb.base/funcargs.exp: print s after run to call2a +PASS: gdb.base/funcargs.exp: print d1 after run to call2a +PASS: gdb.base/funcargs.exp: print i after run to call2a +PASS: gdb.base/funcargs.exp: print f2 after run to call2a +PASS: gdb.base/funcargs.exp: print l after run to call2a +PASS: gdb.base/funcargs.exp: print d2 after run to call2a +PASS: gdb.base/funcargs.exp: continue to call2b +PASS: gdb.base/funcargs.exp: continue to call2c +PASS: gdb.base/funcargs.exp: continue to call2d +PASS: gdb.base/funcargs.exp: continue to call2e +PASS: gdb.base/funcargs.exp: continue to call2f +PASS: gdb.base/funcargs.exp: continue to call2g +PASS: gdb.base/funcargs.exp: continue to call2h +PASS: gdb.base/funcargs.exp: continue to call2i +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: continue to callcb +PASS: gdb.base/funcargs.exp: continue to callcc +PASS: gdb.base/funcargs.exp: continue to callcd +PASS: gdb.base/funcargs.exp: continue to callce +PASS: gdb.base/funcargs.exp: continue to callcf +PASS: gdb.base/funcargs.exp: run to callc1a +PASS: gdb.base/funcargs.exp: continue to callc1b +PASS: gdb.base/funcargs.exp: run to callc2a +PASS: gdb.base/funcargs.exp: continue to callc2b +PASS: gdb.base/funcargs.exp: run to call3a +PASS: gdb.base/funcargs.exp: print *cp +PASS: gdb.base/funcargs.exp: print *sp +PASS: gdb.base/funcargs.exp: print *ip +PASS: gdb.base/funcargs.exp: print *lp +PASS: gdb.base/funcargs.exp: continue to call3b +PASS: gdb.base/funcargs.exp: print *ucp +PASS: gdb.base/funcargs.exp: print *usp +PASS: gdb.base/funcargs.exp: print *uip +PASS: gdb.base/funcargs.exp: print *ulp +PASS: gdb.base/funcargs.exp: continue to call3c +PASS: gdb.base/funcargs.exp: print *fp +PASS: gdb.base/funcargs.exp: print *dp +PASS: gdb.base/funcargs.exp: run to call4a +PASS: gdb.base/funcargs.exp: print *stp +PASS: gdb.base/funcargs.exp: continue to call4b +PASS: gdb.base/funcargs.exp: print *unp (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: locate actual args, structs/unions passed by reference +PASS: gdb.base/funcargs.exp: run to call5a +PASS: gdb.base/funcargs.exp: print st +PASS: gdb.base/funcargs.exp: continue to call5b (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: print un (sizeof long == sizeof int) +PASS: gdb.base/funcargs.exp: run to call6a +PASS: gdb.base/funcargs.exp: backtrace from call6a +PASS: gdb.base/funcargs.exp: continue to call6b +PASS: gdb.base/funcargs.exp: backtrace from call6b +PASS: gdb.base/funcargs.exp: continue to call6c +PASS: gdb.base/funcargs.exp: backtrace from call6c +PASS: gdb.base/funcargs.exp: continue to call6d +PASS: gdb.base/funcargs.exp: backtrace from call6d +PASS: gdb.base/funcargs.exp: continue to call6e +PASS: gdb.base/funcargs.exp: backtrace from call6e +PASS: gdb.base/funcargs.exp: continue to call6f +PASS: gdb.base/funcargs.exp: backtrace from call6f +PASS: gdb.base/funcargs.exp: continue to call6g +PASS: gdb.base/funcargs.exp: backtrace from call6g +PASS: gdb.base/funcargs.exp: continue to call6h +PASS: gdb.base/funcargs.exp: backtrace from call6h +PASS: gdb.base/funcargs.exp: continue to call6i +PASS: gdb.base/funcargs.exp: backtrace from call6i +PASS: gdb.base/funcargs.exp: continue to call6j +PASS: gdb.base/funcargs.exp: backtrace from call6j +PASS: gdb.base/funcargs.exp: continue to call6k +PASS: gdb.base/funcargs.exp: backtrace from call6k +PASS: gdb.base/funcargs.exp: run to call7a +PASS: gdb.base/funcargs.exp: backtrace from call7a +PASS: gdb.base/funcargs.exp: continue to call7b +PASS: gdb.base/funcargs.exp: backtrace from call7b +PASS: gdb.base/funcargs.exp: continue to call7c +PASS: gdb.base/funcargs.exp: backtrace from call7c +PASS: gdb.base/funcargs.exp: continue to call7d +PASS: gdb.base/funcargs.exp: backtrace from call7d +PASS: gdb.base/funcargs.exp: continue to call7e +PASS: gdb.base/funcargs.exp: backtrace from call7e +PASS: gdb.base/funcargs.exp: continue to call7f +PASS: gdb.base/funcargs.exp: backtrace from call7f +PASS: gdb.base/funcargs.exp: continue to call7g +PASS: gdb.base/funcargs.exp: backtrace from call7g +PASS: gdb.base/funcargs.exp: continue to call7h +PASS: gdb.base/funcargs.exp: backtrace from call7h +PASS: gdb.base/funcargs.exp: continue to call7i +PASS: gdb.base/funcargs.exp: backtrace from call7i +PASS: gdb.base/funcargs.exp: continue to call7j +PASS: gdb.base/funcargs.exp: backtrace from call7j +PASS: gdb.base/funcargs.exp: continue to call7k +PASS: gdb.base/funcargs.exp: backtrace from call7k +PASS: gdb.base/funcargs.exp: run to hitbottom +PASS: gdb.base/funcargs.exp: recursive passing of structs by value +PASS: gdb.base/funcargs.exp: print c after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: next in localvars_after_alloca() +PASS: gdb.base/funcargs.exp: print c in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l in localvars_after_alloca +PASS: gdb.base/funcargs.exp: backtrace after alloca +PASS: gdb.base/funcargs.exp: print c in call_after_alloca +PASS: gdb.base/funcargs.exp: print s in call_after_alloca +PASS: gdb.base/funcargs.exp: print i in call_after_alloca +PASS: gdb.base/funcargs.exp: print l in call_after_alloca +PASS: gdb.base/funcargs.exp: backtrace from call_after_alloca_subr +PASS: gdb.base/funcargs.exp: continue to call0a +PASS: gdb.base/funcargs.exp: print c in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print s in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print i in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print l in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: backtrace in indirectly called function +PASS: gdb.base/funcargs.exp: finish from indirectly called function +PASS: gdb.base/funcargs.exp: stepping into indirectly called function +PASS: gdb.base/funcargs.exp: finish from marker_call_with_trampolines +PASS: gdb.base/funcargs.exp: stepping into function called with trampolines +PASS: gdb.base/funcargs.exp: backtrace through call with trampolines +PASS: gdb.base/funcargs.exp: stepping back to main from function called with trampolines +Running ./gdb.base/gcore-buffer-overflow.exp ... +PASS: gdb.base/gcore-buffer-overflow.exp: help gcore +PASS: gdb.base/gcore-buffer-overflow.exp: Set buffer exceeding arguments +PASS: gdb.base/gcore-buffer-overflow.exp: save a corefile +Running ./gdb.base/gcore.exp ... +PASS: gdb.base/gcore.exp: help gcore +PASS: gdb.base/gcore.exp: set breakpoint at terminal_func +PASS: gdb.base/gcore.exp: continue to terminal_func +PASS: gdb.base/gcore.exp: save a corefile +FAIL: gdb.base/gcore.exp: re-load generated corefile (bad file format) +Running ./gdb.base/gcore-relro.exp ... +PASS: gdb.base/gcore-relro.exp: help gcore +PASS: gdb.base/gcore-relro.exp: save a corefile +FAIL: gdb.base/gcore-relro.exp: re-load generated corefile +FAIL: gdb.base/gcore-relro.exp: library got loaded +Running ./gdb.base/gdb1056.exp ... +PASS: gdb.base/gdb1056.exp: print 1/0 +PASS: gdb.base/gdb1056.exp: Test unsigned division by zero +Running ./gdb.base/gdb1090.exp ... +PASS: gdb.base/gdb1090.exp: continue to breakpoint: break-here +PASS: gdb.base/gdb1090.exp: print s24 +Running ./gdb.base/gdb11530.exp ... +PASS: gdb.base/gdb11530.exp: print a.i +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) == sizeof (int) +Running ./gdb.base/gdb11531.exp ... +PASS: gdb.base/gdb11531.exp: Set watchpoint +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at next +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at continue +Running ./gdb.base/gdb1250.exp ... +PASS: gdb.base/gdb1250.exp: backtrace from abort +Running ./gdb.base/gdb1555.exp ... +PASS: gdb.base/gdb1555.exp: Step into shared lib function +PASS: gdb.base/gdb1555.exp: Next while in a shared lib function +Running ./gdb.base/gdb1821.exp ... +PASS: gdb.base/gdb1821.exp: print /x bar +Running ./gdb.base/gdbindex-stabs.exp ... +PASS: gdb.base/gdbindex-stabs.exp: list stabs_function +Running ./gdb.base/gdbvars.exp ... +PASS: gdb.base/gdbvars.exp: set print sevenbit-strings +PASS: gdb.base/gdbvars.exp: Set value-history[1] using $1 +PASS: gdb.base/gdbvars.exp: Set value-history[2] using $2 +PASS: gdb.base/gdbvars.exp: Set value-history[3] using $3 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.base/gdbvars.exp: print 108 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.base/gdbvars.exp: Print value-history[1] using explicit index $1 +PASS: gdb.base/gdbvars.exp: Print value-history[2] using explicit index $2 +PASS: gdb.base/gdbvars.exp: Print value-history[3] using explicit index $3 +PASS: gdb.base/gdbvars.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.base/gdbvars.exp: Use value-history element in arithmetic expression +PASS: gdb.base/gdbvars.exp: Set a new convenience variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable to a new value +PASS: gdb.base/gdbvars.exp: Print new contents of convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable $_ +PASS: gdb.base/gdbvars.exp: Print contents of convenience variable $_ +PASS: gdb.base/gdbvars.exp: Use convenience variable in arithmetic expression +PASS: gdb.base/gdbvars.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.base/gdbvars.exp: Print contents of uninitialized convenience variable +PASS: gdb.base/gdbvars.exp: Set a new convenience variable to a program variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable of program variable +Running ./gdb.base/gnu-debugdata.exp ... +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke i686-pc-linux-gnu-nm +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke sort +PASS: gdb.base/gnu-debugdata.exp: nm - invoke i686-pc-linux-gnu-nm +PASS: gdb.base/gnu-debugdata.exp: nm - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm - invoke sort +PASS: gdb.base/gnu-debugdata.exp: comm +PASS: gdb.base/gnu-debugdata.exp: objcopy 1 +PASS: gdb.base/gnu-debugdata.exp: strip +PASS: gdb.base/gnu-debugdata.exp: copydebug +PASS: gdb.base/gnu-debugdata.exp: addlink +PASS: gdb.base/gnu-debugdata.exp: xz +PASS: gdb.base/gnu-debugdata.exp: objcopy 2 +PASS: gdb.base/gnu-debugdata.exp: no symtab +PASS: gdb.base/gnu-debugdata.exp: have symtab +PASS: gdb.base/gnu-debugdata.exp: unload MiniDebugInfo +Running ./gdb.base/gnu-ifunc.exp ... +PASS: gdb.base/gnu-ifunc.exp: continue to breakpoint: break-at-call +FAIL: gdb.base/gnu-ifunc.exp: p gnu_ifunc (3) +FAIL: gdb.base/gnu-ifunc.exp: step +FAIL: gdb.base/gnu-ifunc.exp: continue to break-at-nextcall +FAIL: gdb.base/gnu-ifunc.exp: continue to breakpoint: nextcall gnu_ifunc +FAIL: gdb.base/gnu-ifunc.exp: nextcall gnu_ifunc skipped +PASS: gdb.base/gnu-ifunc.exp: p gnu_ifunc executing +PASS: gdb.base/gnu-ifunc.exp: info sym gnu_ifunc executing +PASS: gdb.base/gnu-ifunc.exp: info addr gnu_ifunc +PASS: gdb.base/gnu-ifunc.exp: info sym <gnu_ifunc-address> +PASS: gdb.base/gnu-ifunc.exp: static gnu_ifunc +Running ./gdb.base/gnu_vector.exp ... +PASS: gdb.base/gnu_vector.exp: print c4 +PASS: gdb.base/gnu_vector.exp: print c4[2] +PASS: gdb.base/gnu_vector.exp: print i4a +PASS: gdb.base/gnu_vector.exp: print i4b +PASS: gdb.base/gnu_vector.exp: print i4a + i4b +PASS: gdb.base/gnu_vector.exp: print i4a - i4b +PASS: gdb.base/gnu_vector.exp: print i4a * i4b +PASS: gdb.base/gnu_vector.exp: print i4a / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % i4b +PASS: gdb.base/gnu_vector.exp: print i4a++ +PASS: gdb.base/gnu_vector.exp: print ++i4a +PASS: gdb.base/gnu_vector.exp: print i4a-- +PASS: gdb.base/gnu_vector.exp: print --i4a +PASS: gdb.base/gnu_vector.exp: print +i4a +PASS: gdb.base/gnu_vector.exp: print -i4a +PASS: gdb.base/gnu_vector.exp: print i4a & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | i4b +PASS: gdb.base/gnu_vector.exp: print i4a ^ i4b +PASS: gdb.base/gnu_vector.exp: print ~i4a +PASS: gdb.base/gnu_vector.exp: print i4a << i4b +PASS: gdb.base/gnu_vector.exp: print i4a >> i4b +PASS: gdb.base/gnu_vector.exp: print f4a +PASS: gdb.base/gnu_vector.exp: print f4b +PASS: gdb.base/gnu_vector.exp: print f4a + f4b +PASS: gdb.base/gnu_vector.exp: print f4a - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * f4b +PASS: gdb.base/gnu_vector.exp: print f4a / f4b +PASS: gdb.base/gnu_vector.exp: print +f4a +PASS: gdb.base/gnu_vector.exp: print -f4a +PASS: gdb.base/gnu_vector.exp: print (char4) 0x01010101 +PASS: gdb.base/gnu_vector.exp: print (char4) ia +PASS: gdb.base/gnu_vector.exp: print (int2) lla +PASS: gdb.base/gnu_vector.exp: print (int2) 1 +PASS: gdb.base/gnu_vector.exp: print (longlong2) 2 +PASS: gdb.base/gnu_vector.exp: print (float2) 3 +PASS: gdb.base/gnu_vector.exp: print (double2) 4 +PASS: gdb.base/gnu_vector.exp: print (uint4) ia +PASS: gdb.base/gnu_vector.exp: print (int4) -3 +PASS: gdb.base/gnu_vector.exp: print (float4) 4 +PASS: gdb.base/gnu_vector.exp: print i4b = ia +PASS: gdb.base/gnu_vector.exp: print i4a = 3 +PASS: gdb.base/gnu_vector.exp: print f4a = fb +PASS: gdb.base/gnu_vector.exp: print f4b = 2 +PASS: gdb.base/gnu_vector.exp: print c4 + lla +PASS: gdb.base/gnu_vector.exp: print i4a + lla +PASS: gdb.base/gnu_vector.exp: print lla + c4 +PASS: gdb.base/gnu_vector.exp: print lla + i4a +PASS: gdb.base/gnu_vector.exp: print c4 + ib +PASS: gdb.base/gnu_vector.exp: print i4a + ib +PASS: gdb.base/gnu_vector.exp: print i4a + 1 +PASS: gdb.base/gnu_vector.exp: print 1 + i4a +PASS: gdb.base/gnu_vector.exp: print fa - f4b +PASS: gdb.base/gnu_vector.exp: print 2 - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * fb +PASS: gdb.base/gnu_vector.exp: print f4a * 1 +PASS: gdb.base/gnu_vector.exp: print ia / i4b +PASS: gdb.base/gnu_vector.exp: print 2 / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % ib +PASS: gdb.base/gnu_vector.exp: print i4a % 1 +PASS: gdb.base/gnu_vector.exp: print ia & i4b +PASS: gdb.base/gnu_vector.exp: print 2 & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | ib +PASS: gdb.base/gnu_vector.exp: print i4a | 1 +PASS: gdb.base/gnu_vector.exp: print ia ^ i4b +PASS: gdb.base/gnu_vector.exp: print 2 ^ i4b +PASS: gdb.base/gnu_vector.exp: print i4a << ib +PASS: gdb.base/gnu_vector.exp: print i4a << 1 +PASS: gdb.base/gnu_vector.exp: print i4a >> ib +PASS: gdb.base/gnu_vector.exp: print i4a >> 1 +PASS: gdb.base/gnu_vector.exp: print i4a = {2, 4, 8, 16} +PASS: gdb.base/gnu_vector.exp: print i4a <<= ib +PASS: gdb.base/gnu_vector.exp: print i4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + f4a +PASS: gdb.base/gnu_vector.exp: print i2 + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i2 +PASS: gdb.base/gnu_vector.exp: print i4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + f4a +PASS: gdb.base/gnu_vector.exp: print ui4 + i4a +PASS: gdb.base/gnu_vector.exp: print i4a + ui4 +PASS: gdb.base/gnu_vector.exp: print i4a + i2 +PASS: gdb.base/gnu_vector.exp: print i2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + f2 +PASS: gdb.base/gnu_vector.exp: print f2 + f4a +PASS: gdb.base/gnu_vector.exp: print (double2) f2 +PASS: gdb.base/gnu_vector.exp: print (int4) c4 +PASS: gdb.base/gnu_vector.exp: print (char4) i4a +PASS: gdb.base/gnu_vector.exp: ptype c4 +PASS: gdb.base/gnu_vector.exp: ptype char4 +PASS: gdb.base/gnu_vector.exp: ptype i4a +PASS: gdb.base/gnu_vector.exp: ptype int4 +PASS: gdb.base/gnu_vector.exp: ptype f4b +PASS: gdb.base/gnu_vector.exp: ptype float4 +PASS: gdb.base/gnu_vector.exp: ptype union_with_vector_1 +PASS: gdb.base/gnu_vector.exp: ptype struct_with_vector_1 +Running ./gdb.base/hashline1.exp ... +PASS: gdb.base/hashline1.exp: set breakpoint +Running ./gdb.base/hashline2.exp ... +PASS: gdb.base/hashline2.exp: set breakpoint +Running ./gdb.base/hashline3.exp ... +PASS: gdb.base/hashline3.exp: set breakpoint +Running ./gdb.base/hbreak2.exp ... +PASS: gdb.base/hbreak2.exp: hardware breakpoint support +PASS: gdb.base/hbreak2.exp: hardware breakpoint insertion +PASS: gdb.base/hbreak2.exp: hardware breakpoint function +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: use `list' to establish default source file +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line if conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line while conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint info +PASS: gdb.base/hbreak2.exp: hardware breakpoint function (2) +PASS: gdb.base/hbreak2.exp: run until function breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number (2) +PASS: gdb.base/hbreak2.exp: run until breakpoint set at a line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file (2) +PASS: gdb.base/hbreak2.exp: run until file:function(6) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(5) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(4) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(3) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(2) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(1) breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function (2) +PASS: gdb.base/hbreak2.exp: run until quoted breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file (2) +PASS: gdb.base/hbreak2.exp: run until file:linenum breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint offset +1 +PASS: gdb.base/hbreak2.exp: step onto hardware breakpoint +PASS: gdb.base/hbreak2.exp: setting hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: continue to hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint info +PASS: gdb.base/hbreak2.exp: set breakpoint pending off +PASS: gdb.base/hbreak2.exp: hardware break on non-existent source line +PASS: gdb.base/hbreak2.exp: until bp_location1 +PASS: gdb.base/hbreak2.exp: hardware break on default location +PASS: gdb.base/hbreak2.exp: set to-be-silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: set silent break bp_location1 +PASS: gdb.base/hbreak2.exp: info silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: hit silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: stopped for silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on non-existent thread disallowed +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on bogus thread ID disallowed +PASS: gdb.base/hbreak2.exp: hardware breakpoint with trailing garbage disallowed +PASS: gdb.base/hbreak2.exp: step over hardware breakpoint +PASS: gdb.base/hbreak2.exp: clear line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via convenience variable +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/hbreak2.exp: set hardware breakpoint on to-be-called function +PASS: gdb.base/hbreak2.exp: hit hardware breakpoint on called function +PASS: gdb.base/hbreak2.exp: backtrace while in called function +PASS: gdb.base/hbreak2.exp: finish from called function +PASS: gdb.base/hbreak2.exp: hardware break at factorial +PASS: gdb.base/hbreak2.exp: kill program +PASS: gdb.base/hbreak2.exp: run to factorial(6) +PASS: gdb.base/hbreak2.exp: continue to factorial(5) +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5) +PASS: gdb.base/hbreak2.exp: next to recursive call +PASS: gdb.base/hbreak2.exp: next over recursive call +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5.1) +PASS: gdb.base/hbreak2.exp: continue until exit at recursive next test +PASS: gdb.base/hbreak2.exp: hardware breakpoint function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware function breakpoint, optimized file (code motion) +PASS: gdb.base/hbreak2.exp: hardware breakpoint small function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware breakpoint set at small function, optimized file +Running ./gdb.base/hbreak.exp ... +Running ./gdb.base/help.exp ... +PASS: gdb.base/help.exp: disable pagination +PASS: gdb.base/help.exp: help aliases +PASS: gdb.base/help.exp: help breakpoints +PASS: gdb.base/help.exp: help data +PASS: gdb.base/help.exp: help files +PASS: gdb.base/help.exp: help internals +PASS: gdb.base/help.exp: help obscure +PASS: gdb.base/help.exp: help running +PASS: gdb.base/help.exp: help stack +PASS: gdb.base/help.exp: help status +PASS: gdb.base/help.exp: help support +PASS: gdb.base/help.exp: help tracepoints +PASS: gdb.base/help.exp: help user-defined +PASS: gdb.base/help.exp: help breakpoint "b" abbreviation +PASS: gdb.base/help.exp: help breakpoint "br" abbreviation +PASS: gdb.base/help.exp: help breakpoint "bre" abbreviation +PASS: gdb.base/help.exp: help breakpoint "brea" abbreviation +PASS: gdb.base/help.exp: help breakpoint "break" abbreviation +PASS: gdb.base/help.exp: help backtrace "bt" abbreviation +PASS: gdb.base/help.exp: help backtrace +PASS: gdb.base/help.exp: help commands +PASS: gdb.base/help.exp: help delete "d" abbreviation +PASS: gdb.base/help.exp: help delete +PASS: gdb.base/help.exp: help help "h" abbreviation +PASS: gdb.base/help.exp: help help +PASS: gdb.base/help.exp: help show copying +PASS: gdb.base/help.exp: help show warranty +PASS: gdb.base/help.exp: help show commands +PASS: gdb.base/help.exp: help show confirm +PASS: gdb.base/help.exp: help info bogus-gdb-command +PASS: gdb.base/help.exp: help gotcha +PASS: gdb.base/help.exp: apropos \(print[^ bsiedf\".-]\) +PASS: gdb.base/help.exp: apropos handle signal +PASS: gdb.base/help.exp: apropos apropos +Running ./gdb.base/hook-stop-continue.exp ... +PASS: gdb.base/hook-stop-continue.exp: breakpoint line number +PASS: gdb.base/hook-stop-continue.exp: print $do_continue = 1 +PASS: gdb.base/hook-stop-continue.exp: define hook-stop command +PASS: gdb.base/hook-stop-continue.exp: next triggering hook-stop +PASS: gdb.base/hook-stop-continue.exp: next no hook-stop +Running ./gdb.base/hook-stop-frame.exp ... +PASS: gdb.base/hook-stop-frame.exp: breakpoint line number +PASS: gdb.base/hook-stop-frame.exp: define hook-stop command +PASS: gdb.base/hook-stop-frame.exp: hook-stop runs before frame print +Running ./gdb.base/huge.exp ... +PASS: gdb.base/huge.exp: print a very large data object +Running ./gdb.base/ifelse.exp ... +PASS: gdb.base/ifelse.exp: if 1 with empty body +PASS: gdb.base/ifelse.exp: if 0 with empty body +PASS: gdb.base/ifelse.exp: if true else false #1 +PASS: gdb.base/ifelse.exp: if 1 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #2 +PASS: gdb.base/ifelse.exp: if 0 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #3 +PASS: gdb.base/ifelse.exp: create define with empty else +PASS: gdb.base/ifelse.exp: call original define +PASS: gdb.base/ifelse.exp: replace define with if .. else with empty body +PASS: gdb.base/ifelse.exp: call replacement define +Running ./gdb.base/included.exp ... +PASS: gdb.base/included.exp: set listsize 1 +PASS: gdb.base/included.exp: list main +PASS: gdb.base/included.exp: list integer +PASS: gdb.base/included.exp: ptype integer +PASS: gdb.base/included.exp: info variables integer +Running ./gdb.base/inferior-died.exp ... +UNSUPPORTED: gdb.base/inferior-died.exp: inferior-died.exp +Running ./gdb.base/infnan.exp ... +PASS: gdb.base/infnan.exp: print a +PASS: gdb.base/infnan.exp: print b +Running ./gdb.base/info-fun.exp ... +Running ./gdb.base/infoline.exp ... +PASS: gdb.base/infoline.exp: info line infoline.c:18 +Running ./gdb.base/info-macros.exp ... +FAIL: gdb.base/info-macros.exp: info macro -- -all +FAIL: gdb.base/info-macros.exp: info macro -- -all +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -- +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: info macro -invalid-option 1 +PASS: gdb.base/info-macros.exp: info macro -invalid-option +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro -a FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -all -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macros 2 +FAIL: gdb.base/info-macros.exp: info macros 3 +FAIL: gdb.base/info-macros.exp: info macros 4 +FAIL: gdb.base/info-macros.exp: info macros *$pc +FAIL: gdb.base/info-macros.exp: info macros +FAIL: gdb.base/info-macros.exp: info macros 6 +FAIL: gdb.base/info-macros.exp: info macros 7 +KFAIL: gdb.base/info-macros.exp: info macros info-macros.c:42 (PRMS: gdb/NNNN) +Running ./gdb.base/info-os.exp ... +PASS: gdb.base/info-os.exp: get inferior process ID +PASS: gdb.base/info-os.exp: continue to breakpoint: Set breakpoint here +PASS: gdb.base/info-os.exp: get shared memory key +PASS: gdb.base/info-os.exp: get shared memory ID +PASS: gdb.base/info-os.exp: get semaphore key +PASS: gdb.base/info-os.exp: get semaphore ID +PASS: gdb.base/info-os.exp: get message queue key +PASS: gdb.base/info-os.exp: get message queue ID +PASS: gdb.base/info-os.exp: get socket port number +PASS: gdb.base/info-os.exp: get process list +PASS: gdb.base/info-os.exp: get process groups +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get file descriptors +PASS: gdb.base/info-os.exp: get internet-domain sockets +PASS: gdb.base/info-os.exp: get shared-memory regions +PASS: gdb.base/info-os.exp: get semaphores +PASS: gdb.base/info-os.exp: get message queues +PASS: gdb.base/info-os.exp: continue +Running ./gdb.base/info-proc.exp ... +PASS: gdb.base/info-proc.exp: help info proc +PASS: gdb.base/info-proc.exp: info proc without a process +PASS: gdb.base/info-proc.exp: info proc with process +PASS: gdb.base/info-proc.exp: info proc mapping +PASS: gdb.base/info-proc.exp: save a core file +FAIL: gdb.base/info-proc.exp: core break.gcore +FAIL: gdb.base/info-proc.exp: info proc mapping with core file +Running ./gdb.base/info-target.exp ... +PASS: gdb.base/info-target.exp: info target +Running ./gdb.base/interact.exp ... +PASS: gdb.base/interact.exp: set interactive-mode auto +PASS: gdb.base/interact.exp: source script with interactive-mode auto +PASS: gdb.base/interact.exp: sanity check with interactive-mode auto +PASS: gdb.base/interact.exp: show interactive-mode (auto) +PASS: gdb.base/interact.exp: set interactive-mode on +PASS: gdb.base/interact.exp: source script with interactive-mode on +PASS: gdb.base/interact.exp: sanity check with interactive-mode on +PASS: gdb.base/interact.exp: show interactive-mode (on) +PASS: gdb.base/interact.exp: set interactive-mode off +PASS: gdb.base/interact.exp: source script with interactive-mode off +PASS: gdb.base/interact.exp: sanity check with interactive-mode off +PASS: gdb.base/interact.exp: show interactive-mode (off) +Running ./gdb.base/interp.exp ... +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec console "show version" +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec mi "-stack-info-frame" +PASS: gdb.base/interp.exp: interpreter-exec mi1 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi2 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi3 "-break-insert main" +PASS: gdb.base/interp.exp: can list sources +Running ./gdb.base/interrupt.exp ... +Running ./gdb.base/jit.exp ... +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-2: set var argc = 2 +PASS: gdb.base/jit.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: one_jit_test-2: set var count = 2 +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +Running ./gdb.base/jit-simple.exp ... +PASS: gdb.base/jit-simple.exp: blah 1 +PASS: gdb.base/jit-simple.exp: recompile jit-simple.c +PASS: gdb.base/jit-simple.exp: blah 1 +Running ./gdb.base/jit-so.exp ... +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here before-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var jit_libname = "jit-main.so" +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here after-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here before-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var jit_libname = "jit-main.so" +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here after-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 0 +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var argc = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var count = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 1 +PASS: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +Running ./gdb.base/jump.exp ... +PASS: gdb.base/jump.exp: break before jump to non-call +PASS: gdb.base/jump.exp: jump to non-call +PASS: gdb.base/jump.exp: break before jump to call +PASS: gdb.base/jump.exp: jump to call +PASS: gdb.base/jump.exp: disable breakpoint on call +PASS: gdb.base/jump.exp: jump to call with disabled breakpoint +PASS: gdb.base/jump.exp: jump without argument disallowed +PASS: gdb.base/jump.exp: jump with trailing argument junk +PASS: gdb.base/jump.exp: aborted jump out of current function +PASS: gdb.base/jump.exp: jump out of current function +Running ./gdb.base/kill-after-signal.exp ... +PASS: gdb.base/kill-after-signal.exp: handle SIGUSR1 stop print pass +PASS: gdb.base/kill-after-signal.exp: continue +PASS: gdb.base/kill-after-signal.exp: stepi +PASS: gdb.base/kill-after-signal.exp: kill +Running ./gdb.base/label.exp ... +Running ./gdb.base/langs.exp ... +PASS: gdb.base/langs.exp: break on nonexistent function in langs.exp +PASS: gdb.base/langs.exp: show language at csub in langs.exp +PASS: gdb.base/langs.exp: backtrace in langs.exp +PASS: gdb.base/langs.exp: up to foo in langs.exp +PASS: gdb.base/langs.exp: show language at foo in langs.exp +PASS: gdb.base/langs.exp: up to cppsub_ in langs.exp +PASS: gdb.base/langs.exp: show language at cppsub_ in langs.exp +PASS: gdb.base/langs.exp: up to fsub in langs.exp +PASS: gdb.base/langs.exp: show language at fsub in langs.exp +PASS: gdb.base/langs.exp: up to langs0__2do in langs.exp +PASS: gdb.base/langs.exp: show language at langs0__2do in langs.exp +PASS: gdb.base/langs.exp: up to main in langs.exp +PASS: gdb.base/langs.exp: show language at main in langs.exp +PASS: gdb.base/langs.exp: continue until exit at langs.exp +PASS: gdb.base/langs.exp: set lang to minimal +PASS: gdb.base/langs.exp: print parameter value +Running ./gdb.base/ldbl_e308.exp ... +PASS: gdb.base/ldbl_e308.exp: set variable ldbl_308 = 1.6e+308l +PASS: gdb.base/ldbl_e308.exp: print ldbl_308 +Running ./gdb.base/lineinc.exp ... +PASS: gdb.base/lineinc.exp: tolerate macro info with multiple #inclusions per line +Running ./gdb.base/linespecs.exp ... +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c +Running ./gdb.base/list.exp ... +PASS: gdb.base/list.exp: set width 0 +PASS: gdb.base/list.exp: show default list size +PASS: gdb.base/list.exp: list default lines around main +PASS: gdb.base/list.exp: setting listsize to 1 #1 +PASS: gdb.base/list.exp: show listsize 1 #1 +PASS: gdb.base/list.exp: list line 1 with listsize 1 +PASS: gdb.base/list.exp: list line 2 with listsize 1 +PASS: gdb.base/list.exp: setting listsize to 2 #2 +PASS: gdb.base/list.exp: show listsize 2 #2 +PASS: gdb.base/list.exp: list line 1 with listsize 2 +PASS: gdb.base/list.exp: list line 2 with listsize 2 +PASS: gdb.base/list.exp: list line 3 with listsize 2 +PASS: gdb.base/list.exp: setting listsize to 3 #3 +PASS: gdb.base/list.exp: show listsize 3 #3 +PASS: gdb.base/list.exp: list line 1 with listsize 3 +PASS: gdb.base/list.exp: list line 2 with listsize 3 +PASS: gdb.base/list.exp: list line 3 with listsize 3 +PASS: gdb.base/list.exp: setting listsize to 4 #4 +PASS: gdb.base/list.exp: show listsize 4 #4 +PASS: gdb.base/list.exp: list line 1 with listsize 4 +PASS: gdb.base/list.exp: list line 2 with listsize 4 +PASS: gdb.base/list.exp: list line 3 with listsize 4 +PASS: gdb.base/list.exp: list line 4 with listsize 4 +PASS: gdb.base/list.exp: setting listsize to 100 #5 +PASS: gdb.base/list.exp: show listsize 100 #5 +PASS: gdb.base/list.exp: list line 1 with listsize 100 +PASS: gdb.base/list.exp: list line 10 with listsize 100 +PASS: gdb.base/list.exp: setting listsize to 0 #6 +PASS: gdb.base/list.exp: show listsize unlimited #6 +PASS: gdb.base/list.exp: list line 1 with unlimited listsize +PASS: gdb.base/list.exp: setting listsize to 10 #7 +PASS: gdb.base/list.exp: show listsize 10 #7 +PASS: gdb.base/list.exp: list line 1 in include file +PASS: gdb.base/list.exp: list message for lines past EOF +PASS: gdb.base/list.exp: list filename:number (4 tests) +PASS: gdb.base/list.exp: list function in source file 1 +PASS: gdb.base/list.exp: list function in source file 2 +PASS: gdb.base/list.exp: list function in include file +PASS: gdb.base/list.exp: successive list commands to page forward (4 tests) +PASS: gdb.base/list.exp: 4 successive "list -" commands to page backwards +PASS: gdb.base/list.exp: repeat list commands to page forward using 'return' (4 tests) +PASS: gdb.base/list.exp: list range; filename:line1,filename:line2 +PASS: gdb.base/list.exp: list range; line1,line2 +PASS: gdb.base/list.exp: list range; upper bound past EOF +PASS: gdb.base/list.exp: list range; both bounds past EOF +PASS: gdb.base/list.exp: list range, must be same files +PASS: gdb.base/list.exp: list filename:function (5 tests) +PASS: gdb.base/list.exp: list 'list0.c:main' +XFAIL: gdb.base/list.exp: list filename:function; wrong filename rejected +PASS: gdb.base/list.exp: list filename:function; nonexistant file +PASS: gdb.base/list.exp: list filename:function; nonexistant function +PASS: gdb.base/list.exp: set listsize 4 +PASS: gdb.base/list.exp: list long_line +PASS: gdb.base/list.exp: search 4321 +PASS: gdb.base/list.exp: search 6789 +PASS: gdb.base/list.exp: search extremely long line (> 5000 chars) +PASS: gdb.base/list.exp: set listsize 2 +PASS: gdb.base/list.exp: list 1 +PASS: gdb.base/list.exp: list ,5 +Running ./gdb.base/logical.exp ... +PASS: gdb.base/logical.exp: evaluate x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 3, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 1, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 2, y = 2, w = 2, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +Running ./gdb.base/longest-types.exp ... +UNTESTED: gdb.base/longest-types.exp: longest-types.exp +Running ./gdb.base/longjmp.exp ... +PASS: gdb.base/longjmp.exp: breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_1 +PASS: gdb.base/longjmp.exp: next over setjmp (1) +PASS: gdb.base/longjmp.exp: next to longjmp (1) +FAIL: gdb.base/longjmp.exp: next over longjmp(1) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_2 +PASS: gdb.base/longjmp.exp: next over setjmp (2) +FAIL: gdb.base/longjmp.exp: next over call_longjmp (2) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 3 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 3 start +FAIL: gdb.base/longjmp.exp: next over patt3 +Running ./gdb.base/long_long.exp ... +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (char)" (1) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (short)" (2) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (int)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long long)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (void *)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (double)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long double)" (12) +PASS: gdb.base/long_long.exp: continue to breakpoint: Stop here and look +PASS: gdb.base/long_long.exp: hex print p/x +PASS: gdb.base/long_long.exp: decimal print p/x +PASS: gdb.base/long_long.exp: default print val.dec +PASS: gdb.base/long_long.exp: default print val.bin +PASS: gdb.base/long_long.exp: default print val.oct +PASS: gdb.base/long_long.exp: default print hex +PASS: gdb.base/long_long.exp: decimal print p/u +PASS: gdb.base/long_long.exp: binary print +PASS: gdb.base/long_long.exp: octal print +PASS: gdb.base/long_long.exp: print +ve long long +PASS: gdb.base/long_long.exp: decimal print p/d +PASS: gdb.base/long_long.exp: p/d val.oct +PASS: gdb.base/long_long.exp: p/u val.oct +PASS: gdb.base/long_long.exp: p/o val.oct +PASS: gdb.base/long_long.exp: p/t val.oct +PASS: gdb.base/long_long.exp: p/a val.oct +PASS: gdb.base/long_long.exp: p/c val.oct +PASS: gdb.base/long_long.exp: p/f val.oct +PASS: gdb.base/long_long.exp: p/x *(char *)c +PASS: gdb.base/long_long.exp: p/d *(char *)c +PASS: gdb.base/long_long.exp: p/u *(char *)c +PASS: gdb.base/long_long.exp: p/o *(char *)c +PASS: gdb.base/long_long.exp: p/t *(char *)c +PASS: gdb.base/long_long.exp: p/a *(char *)c +PASS: gdb.base/long_long.exp: p/f *(char *)c +PASS: gdb.base/long_long.exp: p/c *(char *)c +PASS: gdb.base/long_long.exp: p/x *(short *)s +PASS: gdb.base/long_long.exp: p/d *(short *)s +PASS: gdb.base/long_long.exp: p/u *(short *)s +PASS: gdb.base/long_long.exp: p/o *(short *)s +PASS: gdb.base/long_long.exp: p/t *(short *)s +PASS: gdb.base/long_long.exp: p/a *(short *)s +PASS: gdb.base/long_long.exp: p/f *(short *)s +PASS: gdb.base/long_long.exp: p/c *(short *)s +PASS: gdb.base/long_long.exp: p/x *(int *)i +PASS: gdb.base/long_long.exp: p/d *(int *)i +PASS: gdb.base/long_long.exp: p/u *(int *)i +PASS: gdb.base/long_long.exp: p/o *(int *)i +PASS: gdb.base/long_long.exp: p/t *(int *)i +PASS: gdb.base/long_long.exp: p/a *(int *)i +PASS: gdb.base/long_long.exp: p/f *(int *)i +PASS: gdb.base/long_long.exp: p/c *(int *)i +PASS: gdb.base/long_long.exp: p/x *(long *)l +PASS: gdb.base/long_long.exp: p/d *(long *)l +PASS: gdb.base/long_long.exp: p/u *(long *)l +PASS: gdb.base/long_long.exp: p/o *(long *)l +PASS: gdb.base/long_long.exp: p/t *(long *)l +PASS: gdb.base/long_long.exp: p/a *(long *)l +PASS: gdb.base/long_long.exp: p/f *(long *)l +PASS: gdb.base/long_long.exp: p/c *(long *)l +PASS: gdb.base/long_long.exp: p/x *(long long *)ll +PASS: gdb.base/long_long.exp: p/d *(long long *)ll +PASS: gdb.base/long_long.exp: p/u *(long long *)ll +PASS: gdb.base/long_long.exp: p/o *(long long *)ll +PASS: gdb.base/long_long.exp: p/t *(long long *)ll +PASS: gdb.base/long_long.exp: p/a *(long long *)ll +PASS: gdb.base/long_long.exp: p/f *(long long *)ll +PASS: gdb.base/long_long.exp: p/c *(long long *)ll +PASS: gdb.base/long_long.exp: set examine size to w +PASS: gdb.base/long_long.exp: x/x w +PASS: gdb.base/long_long.exp: x/d w +PASS: gdb.base/long_long.exp: x/u w +PASS: gdb.base/long_long.exp: x/o w +PASS: gdb.base/long_long.exp: x/t w +PASS: gdb.base/long_long.exp: x/a +PASS: gdb.base/long_long.exp: x/c b +PASS: gdb.base/long_long.exp: x/f &val.oct +PASS: gdb.base/long_long.exp: set examine size to g +PASS: gdb.base/long_long.exp: x/2x g +PASS: gdb.base/long_long.exp: x/2d g +PASS: gdb.base/long_long.exp: x/2u g +PASS: gdb.base/long_long.exp: x/2o g +PASS: gdb.base/long_long.exp: x/2t g +PASS: gdb.base/long_long.exp: x/2a +PASS: gdb.base/long_long.exp: x/2c b +PASS: gdb.base/long_long.exp: x/2f &val.oct +PASS: gdb.base/long_long.exp: x/2bx b +PASS: gdb.base/long_long.exp: x/2bd b +PASS: gdb.base/long_long.exp: x/2bu b +PASS: gdb.base/long_long.exp: x/2bo b +PASS: gdb.base/long_long.exp: x/2bt b +PASS: gdb.base/long_long.exp: x/2ba b +PASS: gdb.base/long_long.exp: x/2bc b +PASS: gdb.base/long_long.exp: x/2bf b +PASS: gdb.base/long_long.exp: x/2hx h +PASS: gdb.base/long_long.exp: x/2hd h +PASS: gdb.base/long_long.exp: x/2hu h +PASS: gdb.base/long_long.exp: x/2ho h +PASS: gdb.base/long_long.exp: x/2ht h +PASS: gdb.base/long_long.exp: x/2ha h +PASS: gdb.base/long_long.exp: x/2hc h +PASS: gdb.base/long_long.exp: x/2hf h +PASS: gdb.base/long_long.exp: x/2wx w +PASS: gdb.base/long_long.exp: x/2wd w +PASS: gdb.base/long_long.exp: x/2wu w +PASS: gdb.base/long_long.exp: x/2wo w +PASS: gdb.base/long_long.exp: x/2wt w +PASS: gdb.base/long_long.exp: x/2wa w +PASS: gdb.base/long_long.exp: x/2wc w +PASS: gdb.base/long_long.exp: x/2wf w +PASS: gdb.base/long_long.exp: x/2gx g +PASS: gdb.base/long_long.exp: x/2gd g +PASS: gdb.base/long_long.exp: x/2gu g +PASS: gdb.base/long_long.exp: x/2go g +PASS: gdb.base/long_long.exp: x/2gt g +PASS: gdb.base/long_long.exp: x/2ga g +PASS: gdb.base/long_long.exp: x/2gc g +PASS: gdb.base/long_long.exp: x/2gf g +Running ./gdb.base/macscp.exp ... +PASS: gdb.base/macscp.exp: list main for support check +UNSUPPORTED: gdb.base/macscp.exp: Skipping test because debug information does not include macro information. +Running ./gdb.base/maint.exp ... +PASS: gdb.base/maint.exp: set height 0 +PASS: gdb.base/maint.exp: maint print registers +PASS: gdb.base/maint.exp: maint check-symtabs +PASS: gdb.base/maint.exp: maint space +PASS: gdb.base/maint.exp: maint space 1 +PASS: gdb.base/maint.exp: maint time +PASS: gdb.base/maint.exp: maint time 1 +PASS: gdb.base/maint.exp: maint time 0 +PASS: gdb.base/maint.exp: maint space 0 +PASS: gdb.base/maint.exp: maint demangle +PASS: gdb.base/maint.exp: maint demangle main +PASS: gdb.base/maint.exp: maint print statistics +PASS: gdb.base/maint.exp: maint print dummy-frames +PASS: gdb.base/maint.exp: maint print objfiles: header +PASS: gdb.base/maint.exp: maint print objfiles: psymtabs +PASS: gdb.base/maint.exp: maint print objfiles: symtabs +PASS: gdb.base/maint.exp: maint print psymbols w/o args +PASS: gdb.base/maint.exp: maint print psymbols 1 +PASS: gdb.base/maint.exp: shell rm -f psymbols_output +PASS: gdb.base/maint.exp: maint print msymbols w/o args +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output +PASS: gdb.base/maint.exp: cd to objdir +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output2 +PASS: gdb.base/maint.exp: cd to mydir +PASS: gdb.base/maint.exp: maint print symbols w/o args +PASS: gdb.base/maint.exp: maint print symbols +PASS: gdb.base/maint.exp: shell rm -f symbols_output +PASS: gdb.base/maint.exp: maint print type +PASS: gdb.base/maint.exp: maint info sections +PASS: gdb.base/maint.exp: maint info sections .text +PASS: gdb.base/maint.exp: maint info sections CODE +PASS: gdb.base/maint.exp: maint info sections DATA +PASS: gdb.base/maint.exp: maint info breakpoints +PASS: gdb.base/maint.exp: maint print w/o args +PASS: gdb.base/maint.exp: maint info w/o args +PASS: gdb.base/maint.exp: maint w/o args +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: help maint check-symtabs +PASS: gdb.base/maint.exp: help maint space +PASS: gdb.base/maint.exp: help maint time +PASS: gdb.base/maint.exp: help maint demangle +PASS: gdb.base/maint.exp: help maint dump-me +PASS: gdb.base/maint.exp: help maint internal-error +PASS: gdb.base/maint.exp: help maint internal-warning +PASS: gdb.base/maint.exp: help maint print statistics +PASS: gdb.base/maint.exp: help maint print dummy-frames +PASS: gdb.base/maint.exp: help maint print objfiles +PASS: gdb.base/maint.exp: help maint print psymbols +PASS: gdb.base/maint.exp: help maint print msymbols +PASS: gdb.base/maint.exp: help maint print symbols +PASS: gdb.base/maint.exp: help maint print type +PASS: gdb.base/maint.exp: help maint info sections +PASS: gdb.base/maint.exp: help maint info breakpoints +PASS: gdb.base/maint.exp: help maint info +PASS: gdb.base/maint.exp: help maint print +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: maint dump-me +PASS: gdb.base/maint.exp: maint internal-error +PASS: gdb.base/maint.exp: internal-error resync +Running ./gdb.base/memattr.exp ... +PASS: gdb.base/memattr.exp: create mem region 1 +PASS: gdb.base/memattr.exp: create mem region 2 +PASS: gdb.base/memattr.exp: create mem region 3 +PASS: gdb.base/memattr.exp: create mem region 4 +PASS: gdb.base/memattr.exp: create mem region 5 +PASS: gdb.base/memattr.exp: info mem (1) +PASS: gdb.base/memattr.exp: mem1 cannot be read +PASS: gdb.base/memattr.exp: mem1 can be written +PASS: gdb.base/memattr.exp: mem2 cannot be written +PASS: gdb.base/memattr.exp: mem2 can be read +PASS: gdb.base/memattr.exp: disable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was disabled +PASS: gdb.base/memattr.exp: enable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was enabled +PASS: gdb.base/memattr.exp: disable mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were disabled +PASS: gdb.base/memattr.exp: enable mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were enabled +PASS: gdb.base/memattr.exp: disable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were disabled +PASS: gdb.base/memattr.exp: enable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were enabled +PASS: gdb.base/memattr.exp: disable non-existant regions +PASS: gdb.base/memattr.exp: delete mem 1 +PASS: gdb.base/memattr.exp: mem 1 was deleted +PASS: gdb.base/memattr.exp: delete mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were deleted +PASS: gdb.base/memattr.exp: delete mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were deleted +PASS: gdb.base/memattr.exp: delete non-existant region +PASS: gdb.base/memattr.exp: mem 0x30 0x60 ro +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x60 0x70: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x80 0x0: no-overlap +PASS: gdb.base/memattr.exp: mem 0x30 0x0 ro +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x00 0x10: no-overlap +Running ./gdb.base/mips_pro.exp ... +PASS: gdb.base/mips_pro.exp: backtrace +Running ./gdb.base/miscexprs.exp ... +PASS: gdb.base/miscexprs.exp: continue to marker1 +PASS: gdb.base/miscexprs.exp: up from marker1 +PASS: gdb.base/miscexprs.exp: print value of &ibig.i[0] +PASS: gdb.base/miscexprs.exp: print value of &cbig.c[0] +PASS: gdb.base/miscexprs.exp: print value of &fbig.f[0] +PASS: gdb.base/miscexprs.exp: print value of &dbig.d[0] +PASS: gdb.base/miscexprs.exp: print value of &sbig.s[0] +PASS: gdb.base/miscexprs.exp: print value of &lbig.l[0] +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] | 1 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] & 127 +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] * 10 +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] * sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of fbig.f[100] * dbig.d[202] +PASS: gdb.base/miscexprs.exp: print value of !(sbig.s[90] * 2) +PASS: gdb.base/miscexprs.exp: print value of sizeof sbig +PASS: gdb.base/miscexprs.exp: print value of sizeof cbig +PASS: gdb.base/miscexprs.exp: print value of sizeof lbig / sizeof long +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] << 2 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] >> 4 +PASS: gdb.base/miscexprs.exp: print value of lbig.l[333] >> 6 +Running ./gdb.base/morestack.exp ... +PASS: gdb.base/morestack.exp: continue +FAIL: gdb.base/morestack.exp: up 3000 +Running ./gdb.base/moribund-step.exp ... +PASS: gdb.base/moribund-step.exp: set non-stop on +Running ./gdb.base/multi-forks.exp ... +Running ./gdb.base/nextoverexit.exp ... +PASS: gdb.base/nextoverexit.exp: next over exit +Running ./gdb.base/nodebug.exp ... +PASS: gdb.base/nodebug.exp: p top +PASS: gdb.base/nodebug.exp: whatis top +PASS: gdb.base/nodebug.exp: ptype top +PASS: gdb.base/nodebug.exp: p middle +PASS: gdb.base/nodebug.exp: whatis middle +PASS: gdb.base/nodebug.exp: ptype middle +PASS: gdb.base/nodebug.exp: p dataglobal +PASS: gdb.base/nodebug.exp: whatis dataglobal +PASS: gdb.base/nodebug.exp: ptype dataglobal +PASS: gdb.base/nodebug.exp: p datalocal +PASS: gdb.base/nodebug.exp: whatis datalocal +PASS: gdb.base/nodebug.exp: ptype datalocal +PASS: gdb.base/nodebug.exp: p bssglobal +PASS: gdb.base/nodebug.exp: whatis bssglobal +PASS: gdb.base/nodebug.exp: ptype bssglobal +PASS: gdb.base/nodebug.exp: p bsslocal +PASS: gdb.base/nodebug.exp: whatis bsslocal +PASS: gdb.base/nodebug.exp: ptype bsslocal +PASS: gdb.base/nodebug.exp: backtrace from inner in nodebug.exp +PASS: gdb.base/nodebug.exp: p/c array_index("abcdef",2) +PASS: gdb.base/nodebug.exp: backtrace from middle in nodebug.exp +Running ./gdb.base/nofield.exp ... +PASS: gdb.base/nofield.exp: ptype struct not_empty +PASS: gdb.base/nofield.exp: ptype struct empty +PASS: gdb.base/nofield.exp: ptype union empty_union +Running ./gdb.base/nostdlib.exp ... +UNTESTED: gdb.base/nostdlib.exp: nostdlib.exp +Running ./gdb.base/opaque.exp ... +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 2 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 2 +Running ./gdb.base/overlays.exp ... +Running ./gdb.base/page.exp ... +PASS: gdb.base/page.exp: set pagination off +PASS: gdb.base/page.exp: pagination is off +PASS: gdb.base/page.exp: unpaged help +PASS: gdb.base/page.exp: set pagination on +PASS: gdb.base/page.exp: pagination is on +PASS: gdb.base/page.exp: set height 10 +PASS: gdb.base/page.exp: paged help +PASS: gdb.base/page.exp: q +Running ./gdb.base/pc-fp.exp ... +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$pc" +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$fp" +PASS: gdb.base/pc-fp.exp: display/i $pc +PASS: gdb.base/pc-fp.exp: display/w $fp +PASS: gdb.base/pc-fp.exp: info register $pc +PASS: gdb.base/pc-fp.exp: info register $fp +PASS: gdb.base/pc-fp.exp: info register pc fp +Running ./gdb.base/pending.exp ... +PASS: gdb.base/pending.exp: set pending breakpoint (without symbols) +PASS: gdb.base/pending.exp: complete condition +PASS: gdb.base/pending.exp: single pending breakpoint info (without symbols) +PASS: gdb.base/pending.exp: run to resolved breakpoint 1 (without symbols) +PASS: gdb.base/pending.exp: set pending breakpoint +PASS: gdb.base/pending.exp: single pending breakpoint info +PASS: gdb.base/pending.exp: breakpoint function +PASS: gdb.base/pending.exp: pending plus real breakpoint info +PASS: gdb.base/pending.exp: Don't set pending breakpoint +PASS: gdb.base/pending.exp: condition 1 k == 1 +PASS: gdb.base/pending.exp: pending plus condition +PASS: gdb.base/pending.exp: disable 1 +PASS: gdb.base/pending.exp: pending disabled +PASS: gdb.base/pending.exp: Set commands for pending breakpoint +PASS: gdb.base/pending.exp: pending disabled plus commands +PASS: gdb.base/pending.exp: Set pending breakpoint 2 +PASS: gdb.base/pending.exp: multiple pending breakpoints +PASS: gdb.base/pending.exp: Set pending breakpoint 3 +PASS: gdb.base/pending.exp: set ignore count on pending breakpoint 3 +PASS: gdb.base/pending.exp: multiple pending breakpoints 2 +PASS: gdb.base/pending.exp: running to main +PASS: gdb.base/pending.exp: re-enabling pending breakpoint that can resolve instantly +PASS: gdb.base/pending.exp: continue to resolved breakpoint 2 +PASS: gdb.base/pending.exp: continue to resolved breakpoint 1 +PASS: gdb.base/pending.exp: Disable other breakpoints +PASS: gdb.base/pending.exp: Disable other breakpoints +PASS: gdb.base/pending.exp: continue to resolved breakpoint 3 +PASS: gdb.base/pending.exp: set imaginary pending breakpoint +PASS: gdb.base/pending.exp: rerun to main +PASS: gdb.base/pending.exp: verify pending breakpoint after restart +Running ./gdb.base/permissions.exp ... +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: enable observer mode +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: disable observer mode +PASS: gdb.base/permissions.exp: set non-stop off +PASS: gdb.base/permissions.exp: set a global +PASS: gdb.base/permissions.exp: print x +PASS: gdb.base/permissions.exp: set may-write-memory off +PASS: gdb.base/permissions.exp: try to set a global +PASS: gdb.base/permissions.exp: print x +Running ./gdb.base/pie-execl.exp ... +Running ./gdb.base/pointers.exp ... +PASS: gdb.base/pointers.exp: continuing after dummy() +PASS: gdb.base/pointers.exp: set pointer to beginning of array +PASS: gdb.base/pointers.exp: set pointer to end of array +PASS: gdb.base/pointers.exp: print object pointed to +PASS: gdb.base/pointers.exp: print object pointed to #2 +PASS: gdb.base/pointers.exp: pointer1==pointer2 +PASS: gdb.base/pointers.exp: pointer1!=pointer2 +PASS: gdb.base/pointers.exp: pointer1<=pointer2 +PASS: gdb.base/pointers.exp: pointer1>=pointer2 +PASS: gdb.base/pointers.exp: pointer1<pointer2 +PASS: gdb.base/pointers.exp: pointer1>pointer2 +PASS: gdb.base/pointers.exp: set y = *v_int_pointer++ +PASS: gdb.base/pointers.exp: pointer assignment +PASS: gdb.base/pointers.exp: and post-increment +PASS: gdb.base/pointers.exp: set y = *--v_int_pointer2 +PASS: gdb.base/pointers.exp: pointer assignment +PASS: gdb.base/pointers.exp: and pre-decrement +PASS: gdb.base/pointers.exp: set y =v_int_pointer-v_int_pointer2 +PASS: gdb.base/pointers.exp: pointer1-pointer2 +PASS: gdb.base/pointers.exp: set v_int_pointer=v_int_array +PASS: gdb.base/pointers.exp: print array element through pointer +PASS: gdb.base/pointers.exp: print array element through pointer #2 +PASS: gdb.base/pointers.exp: print array element through pointer #3 +PASS: gdb.base/pointers.exp: print array element through pointer #4 +PASS: gdb.base/pointers.exp: print array element through pointer #5 +PASS: gdb.base/pointers.exp: increment rptr +PASS: gdb.base/pointers.exp: print array element through pointer #6 +PASS: gdb.base/pointers.exp: print array element through pointer #7 +PASS: gdb.base/pointers.exp: print array element through pointer #8 +PASS: gdb.base/pointers.exp: print array element w/ pointer arithmetic +PASS: gdb.base/pointers.exp: print through ptr to ptr +PASS: gdb.base/pointers.exp: continue +PASS: gdb.base/pointers.exp: up from marker1 +PASS: gdb.base/pointers.exp: print value of *pUC +PASS: gdb.base/pointers.exp: ptype pUC +PASS: gdb.base/pointers.exp: print value of *pS +PASS: gdb.base/pointers.exp: ptype pS +PASS: gdb.base/pointers.exp: print value of *pUS +PASS: gdb.base/pointers.exp: ptype pUS +PASS: gdb.base/pointers.exp: print value of *pI +PASS: gdb.base/pointers.exp: ptype pI +PASS: gdb.base/pointers.exp: print value of *pUI +PASS: gdb.base/pointers.exp: ptype pUI +PASS: gdb.base/pointers.exp: print value of *pL +PASS: gdb.base/pointers.exp: ptype pL +PASS: gdb.base/pointers.exp: print value of *pUL +PASS: gdb.base/pointers.exp: ptype pUL +PASS: gdb.base/pointers.exp: print value of *pF +PASS: gdb.base/pointers.exp: ptype pF +PASS: gdb.base/pointers.exp: print value of *pD +PASS: gdb.base/pointers.exp: ptype pD +PASS: gdb.base/pointers.exp: print value of ******ppppppC +PASS: gdb.base/pointers.exp: ptype pC +PASS: gdb.base/pointers.exp: ptype ppC +PASS: gdb.base/pointers.exp: ptype pppC +PASS: gdb.base/pointers.exp: ptype ppppC +PASS: gdb.base/pointers.exp: ptype pppppC +PASS: gdb.base/pointers.exp: ptype ppppppC +PASS: gdb.base/pointers.exp: p instance.array_variable + 0 +Running ./gdb.base/pr10179.exp ... +PASS: gdb.base/pr10179.exp: rbreak foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c:foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c : .* +Running ./gdb.base/pr11022.exp ... +Running ./gdb.base/prelink.exp ... +Running ./gdb.base/printcmds.exp ... +PASS: gdb.base/printcmds.exp: print $pc +PASS: gdb.base/printcmds.exp: print "abc" +PASS: gdb.base/printcmds.exp: print sizeof ("abc") +PASS: gdb.base/printcmds.exp: ptype "abc" +PASS: gdb.base/printcmds.exp: print $cvar = "abc" +PASS: gdb.base/printcmds.exp: print sizeof ($cvar) +PASS: gdb.base/printcmds.exp: print $pc (with file) +PASS: gdb.base/printcmds.exp: set print sevenbit-strings +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set width 0 +PASS: gdb.base/printcmds.exp: p ctable1[120] #1 +PASS: gdb.base/printcmds.exp: p 123 +PASS: gdb.base/printcmds.exp: p -123 +PASS: gdb.base/printcmds.exp: p/d 123 +PASS: gdb.base/printcmds.exp: p 0123 +PASS: gdb.base/printcmds.exp: p 00123 +PASS: gdb.base/printcmds.exp: p -0123 +PASS: gdb.base/printcmds.exp: p/o 0123 +PASS: gdb.base/printcmds.exp: p 0x123 +PASS: gdb.base/printcmds.exp: p -0x123 +PASS: gdb.base/printcmds.exp: p 0x0123 +PASS: gdb.base/printcmds.exp: p -0x0123 +PASS: gdb.base/printcmds.exp: p 0xABCDEF +PASS: gdb.base/printcmds.exp: p 0xabcdef +PASS: gdb.base/printcmds.exp: p 0xAbCdEf +PASS: gdb.base/printcmds.exp: p/x 0x123 +PASS: gdb.base/printcmds.exp: p 0b0 +PASS: gdb.base/printcmds.exp: p 0b1111 +PASS: gdb.base/printcmds.exp: p 0B1111 +PASS: gdb.base/printcmds.exp: p -0b1111 +PASS: gdb.base/printcmds.exp: reject p 0x +PASS: gdb.base/printcmds.exp: reject p 0b +PASS: gdb.base/printcmds.exp: p '' +PASS: gdb.base/printcmds.exp: p ''' +PASS: gdb.base/printcmds.exp: reject p '\' +PASS: gdb.base/printcmds.exp: reject p '\\\' +PASS: gdb.base/printcmds.exp: reject p DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 09 +PASS: gdb.base/printcmds.exp: reject p 079 +PASS: gdb.base/printcmds.exp: reject p 0xG +PASS: gdb.base/printcmds.exp: reject p 0xAG +PASS: gdb.base/printcmds.exp: reject p 0b2 +PASS: gdb.base/printcmds.exp: reject p 0b12 +PASS: gdb.base/printcmds.exp: check for floating addition +PASS: gdb.base/printcmds.exp: p 1. +PASS: gdb.base/printcmds.exp: p 1.5 +PASS: gdb.base/printcmds.exp: p 1.f +PASS: gdb.base/printcmds.exp: p 1.5f +PASS: gdb.base/printcmds.exp: p 1.l +PASS: gdb.base/printcmds.exp: p 1.5l +PASS: gdb.base/printcmds.exp: p 0x1.1 +PASS: gdb.base/printcmds.exp: reject p 123DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 123foobar.bazfoo3 +PASS: gdb.base/printcmds.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.base/printcmds.exp: reject p 1.1x +PASS: gdb.base/printcmds.exp: reject p 1.1ff +PASS: gdb.base/printcmds.exp: reject p 1.1ll +PASS: gdb.base/printcmds.exp: p 'a' +PASS: gdb.base/printcmds.exp: p/c 'a' +PASS: gdb.base/printcmds.exp: p/x 'a' +PASS: gdb.base/printcmds.exp: p/d 'a' +PASS: gdb.base/printcmds.exp: p/t 'a' +PASS: gdb.base/printcmds.exp: p '\141' +PASS: gdb.base/printcmds.exp: p/x '\377' +PASS: gdb.base/printcmds.exp: p '\'' +PASS: gdb.base/printcmds.exp: p '\\' +PASS: gdb.base/printcmds.exp: p ctable1[0] +PASS: gdb.base/printcmds.exp: p ctable1[1] +PASS: gdb.base/printcmds.exp: p ctable1[2] +PASS: gdb.base/printcmds.exp: p ctable1[3] +PASS: gdb.base/printcmds.exp: p ctable1[4] +PASS: gdb.base/printcmds.exp: p ctable1[5] +PASS: gdb.base/printcmds.exp: p ctable1[6] +PASS: gdb.base/printcmds.exp: p ctable1[7] +PASS: gdb.base/printcmds.exp: p ctable1[8] +PASS: gdb.base/printcmds.exp: p ctable1[9] +PASS: gdb.base/printcmds.exp: p ctable1[10] +PASS: gdb.base/printcmds.exp: p ctable1[11] +PASS: gdb.base/printcmds.exp: p ctable1[12] +PASS: gdb.base/printcmds.exp: p ctable1[13] +PASS: gdb.base/printcmds.exp: p ctable1[14] +PASS: gdb.base/printcmds.exp: p ctable1[15] +PASS: gdb.base/printcmds.exp: p ctable1[16] +PASS: gdb.base/printcmds.exp: p ctable1[17] +PASS: gdb.base/printcmds.exp: p ctable1[18] +PASS: gdb.base/printcmds.exp: p ctable1[19] +PASS: gdb.base/printcmds.exp: p ctable1[20] +PASS: gdb.base/printcmds.exp: p ctable1[21] +PASS: gdb.base/printcmds.exp: p ctable1[22] +PASS: gdb.base/printcmds.exp: p ctable1[23] +PASS: gdb.base/printcmds.exp: p ctable1[24] +PASS: gdb.base/printcmds.exp: p ctable1[25] +PASS: gdb.base/printcmds.exp: p ctable1[26] +PASS: gdb.base/printcmds.exp: p ctable1[27] +PASS: gdb.base/printcmds.exp: p ctable1[28] +PASS: gdb.base/printcmds.exp: p ctable1[29] +PASS: gdb.base/printcmds.exp: p ctable1[30] +PASS: gdb.base/printcmds.exp: p ctable1[31] +PASS: gdb.base/printcmds.exp: p ctable1[32] +PASS: gdb.base/printcmds.exp: p ctable1[33] +PASS: gdb.base/printcmds.exp: p ctable1[34] +PASS: gdb.base/printcmds.exp: p ctable1[35] +PASS: gdb.base/printcmds.exp: p ctable1[36] +PASS: gdb.base/printcmds.exp: p ctable1[37] +PASS: gdb.base/printcmds.exp: p ctable1[38] +PASS: gdb.base/printcmds.exp: p ctable1[39] +PASS: gdb.base/printcmds.exp: p ctable1[40] +PASS: gdb.base/printcmds.exp: p ctable1[41] +PASS: gdb.base/printcmds.exp: p ctable1[42] +PASS: gdb.base/printcmds.exp: p ctable1[43] +PASS: gdb.base/printcmds.exp: p ctable1[44] +PASS: gdb.base/printcmds.exp: p ctable1[45] +PASS: gdb.base/printcmds.exp: p ctable1[46] +PASS: gdb.base/printcmds.exp: p ctable1[47] +PASS: gdb.base/printcmds.exp: p ctable1[48] +PASS: gdb.base/printcmds.exp: p ctable1[49] +PASS: gdb.base/printcmds.exp: p ctable1[50] +PASS: gdb.base/printcmds.exp: p ctable1[51] +PASS: gdb.base/printcmds.exp: p ctable1[52] +PASS: gdb.base/printcmds.exp: p ctable1[53] +PASS: gdb.base/printcmds.exp: p ctable1[54] +PASS: gdb.base/printcmds.exp: p ctable1[55] +PASS: gdb.base/printcmds.exp: p ctable1[56] +PASS: gdb.base/printcmds.exp: p ctable1[57] +PASS: gdb.base/printcmds.exp: p ctable1[58] +PASS: gdb.base/printcmds.exp: p ctable1[59] +PASS: gdb.base/printcmds.exp: p ctable1[60] +PASS: gdb.base/printcmds.exp: p ctable1[61] +PASS: gdb.base/printcmds.exp: p ctable1[62] +PASS: gdb.base/printcmds.exp: p ctable1[63] +PASS: gdb.base/printcmds.exp: p ctable1[64] +PASS: gdb.base/printcmds.exp: p ctable1[65] +PASS: gdb.base/printcmds.exp: p ctable1[66] +PASS: gdb.base/printcmds.exp: p ctable1[67] +PASS: gdb.base/printcmds.exp: p ctable1[68] +PASS: gdb.base/printcmds.exp: p ctable1[69] +PASS: gdb.base/printcmds.exp: p ctable1[70] +PASS: gdb.base/printcmds.exp: p ctable1[71] +PASS: gdb.base/printcmds.exp: p ctable1[72] +PASS: gdb.base/printcmds.exp: p ctable1[73] +PASS: gdb.base/printcmds.exp: p ctable1[74] +PASS: gdb.base/printcmds.exp: p ctable1[75] +PASS: gdb.base/printcmds.exp: p ctable1[76] +PASS: gdb.base/printcmds.exp: p ctable1[77] +PASS: gdb.base/printcmds.exp: p ctable1[78] +PASS: gdb.base/printcmds.exp: p ctable1[79] +PASS: gdb.base/printcmds.exp: p ctable1[80] +PASS: gdb.base/printcmds.exp: p ctable1[81] +PASS: gdb.base/printcmds.exp: p ctable1[82] +PASS: gdb.base/printcmds.exp: p ctable1[83] +PASS: gdb.base/printcmds.exp: p ctable1[84] +PASS: gdb.base/printcmds.exp: p ctable1[85] +PASS: gdb.base/printcmds.exp: p ctable1[86] +PASS: gdb.base/printcmds.exp: p ctable1[87] +PASS: gdb.base/printcmds.exp: p ctable1[88] +PASS: gdb.base/printcmds.exp: p ctable1[89] +PASS: gdb.base/printcmds.exp: p ctable1[90] +PASS: gdb.base/printcmds.exp: p ctable1[91] +PASS: gdb.base/printcmds.exp: p ctable1[92] +PASS: gdb.base/printcmds.exp: p ctable1[93] +PASS: gdb.base/printcmds.exp: p ctable1[94] +PASS: gdb.base/printcmds.exp: p ctable1[95] +PASS: gdb.base/printcmds.exp: p ctable1[96] +PASS: gdb.base/printcmds.exp: p ctable1[97] +PASS: gdb.base/printcmds.exp: p ctable1[98] +PASS: gdb.base/printcmds.exp: p ctable1[99] +PASS: gdb.base/printcmds.exp: p ctable1[100] +PASS: gdb.base/printcmds.exp: p ctable1[101] +PASS: gdb.base/printcmds.exp: p ctable1[102] +PASS: gdb.base/printcmds.exp: p ctable1[103] +PASS: gdb.base/printcmds.exp: p ctable1[104] +PASS: gdb.base/printcmds.exp: p ctable1[105] +PASS: gdb.base/printcmds.exp: p ctable1[106] +PASS: gdb.base/printcmds.exp: p ctable1[107] +PASS: gdb.base/printcmds.exp: p ctable1[108] +PASS: gdb.base/printcmds.exp: p ctable1[109] +PASS: gdb.base/printcmds.exp: p ctable1[110] +PASS: gdb.base/printcmds.exp: p ctable1[111] +PASS: gdb.base/printcmds.exp: p ctable1[112] +PASS: gdb.base/printcmds.exp: p ctable1[113] +PASS: gdb.base/printcmds.exp: p ctable1[114] +PASS: gdb.base/printcmds.exp: p ctable1[115] +PASS: gdb.base/printcmds.exp: p ctable1[116] +PASS: gdb.base/printcmds.exp: p ctable1[117] +PASS: gdb.base/printcmds.exp: p ctable1[118] +PASS: gdb.base/printcmds.exp: p ctable1[119] +PASS: gdb.base/printcmds.exp: p ctable1[120] +PASS: gdb.base/printcmds.exp: p ctable1[121] +PASS: gdb.base/printcmds.exp: p ctable1[122] +PASS: gdb.base/printcmds.exp: p ctable1[123] +PASS: gdb.base/printcmds.exp: p ctable1[124] +PASS: gdb.base/printcmds.exp: p ctable1[125] +PASS: gdb.base/printcmds.exp: p ctable1[126] +PASS: gdb.base/printcmds.exp: p ctable1[127] +PASS: gdb.base/printcmds.exp: p ctable1[128] +PASS: gdb.base/printcmds.exp: p ctable1[129] +PASS: gdb.base/printcmds.exp: p ctable1[130] +PASS: gdb.base/printcmds.exp: p ctable1[131] +PASS: gdb.base/printcmds.exp: p ctable1[132] +PASS: gdb.base/printcmds.exp: p ctable1[133] +PASS: gdb.base/printcmds.exp: p ctable1[134] +PASS: gdb.base/printcmds.exp: p ctable1[135] +PASS: gdb.base/printcmds.exp: p ctable1[136] +PASS: gdb.base/printcmds.exp: p ctable1[137] +PASS: gdb.base/printcmds.exp: p ctable1[138] +PASS: gdb.base/printcmds.exp: p ctable1[139] +PASS: gdb.base/printcmds.exp: p ctable1[140] +PASS: gdb.base/printcmds.exp: p ctable1[141] +PASS: gdb.base/printcmds.exp: p ctable1[142] +PASS: gdb.base/printcmds.exp: p ctable1[143] +PASS: gdb.base/printcmds.exp: p ctable1[144] +PASS: gdb.base/printcmds.exp: p ctable1[145] +PASS: gdb.base/printcmds.exp: p ctable1[146] +PASS: gdb.base/printcmds.exp: p ctable1[147] +PASS: gdb.base/printcmds.exp: p ctable1[148] +PASS: gdb.base/printcmds.exp: p ctable1[149] +PASS: gdb.base/printcmds.exp: p ctable1[150] +PASS: gdb.base/printcmds.exp: p ctable1[151] +PASS: gdb.base/printcmds.exp: p ctable1[152] +PASS: gdb.base/printcmds.exp: p ctable1[153] +PASS: gdb.base/printcmds.exp: p ctable1[154] +PASS: gdb.base/printcmds.exp: p ctable1[155] +PASS: gdb.base/printcmds.exp: p ctable1[156] +PASS: gdb.base/printcmds.exp: p ctable1[157] +PASS: gdb.base/printcmds.exp: p ctable1[158] +PASS: gdb.base/printcmds.exp: p ctable1[159] +PASS: gdb.base/printcmds.exp: p ctable1[160] +PASS: gdb.base/printcmds.exp: p ctable1[161] +PASS: gdb.base/printcmds.exp: p ctable1[162] +PASS: gdb.base/printcmds.exp: p ctable1[163] +PASS: gdb.base/printcmds.exp: p ctable1[164] +PASS: gdb.base/printcmds.exp: p ctable1[165] +PASS: gdb.base/printcmds.exp: p ctable1[166] +PASS: gdb.base/printcmds.exp: p ctable1[167] +PASS: gdb.base/printcmds.exp: p ctable1[168] +PASS: gdb.base/printcmds.exp: p ctable1[169] +PASS: gdb.base/printcmds.exp: p ctable1[170] +PASS: gdb.base/printcmds.exp: p ctable1[171] +PASS: gdb.base/printcmds.exp: p ctable1[172] +PASS: gdb.base/printcmds.exp: p ctable1[173] +PASS: gdb.base/printcmds.exp: p ctable1[174] +PASS: gdb.base/printcmds.exp: p ctable1[175] +PASS: gdb.base/printcmds.exp: p ctable1[176] +PASS: gdb.base/printcmds.exp: p ctable1[177] +PASS: gdb.base/printcmds.exp: p ctable1[178] +PASS: gdb.base/printcmds.exp: p ctable1[179] +PASS: gdb.base/printcmds.exp: p ctable1[180] +PASS: gdb.base/printcmds.exp: p ctable1[181] +PASS: gdb.base/printcmds.exp: p ctable1[182] +PASS: gdb.base/printcmds.exp: p ctable1[183] +PASS: gdb.base/printcmds.exp: p ctable1[184] +PASS: gdb.base/printcmds.exp: p ctable1[185] +PASS: gdb.base/printcmds.exp: p ctable1[186] +PASS: gdb.base/printcmds.exp: p ctable1[187] +PASS: gdb.base/printcmds.exp: p ctable1[188] +PASS: gdb.base/printcmds.exp: p ctable1[189] +PASS: gdb.base/printcmds.exp: p ctable1[190] +PASS: gdb.base/printcmds.exp: p ctable1[191] +PASS: gdb.base/printcmds.exp: p ctable1[192] +PASS: gdb.base/printcmds.exp: p ctable1[193] +PASS: gdb.base/printcmds.exp: p ctable1[194] +PASS: gdb.base/printcmds.exp: p ctable1[195] +PASS: gdb.base/printcmds.exp: p ctable1[196] +PASS: gdb.base/printcmds.exp: p ctable1[197] +PASS: gdb.base/printcmds.exp: p ctable1[198] +PASS: gdb.base/printcmds.exp: p ctable1[199] +PASS: gdb.base/printcmds.exp: p ctable1[200] +PASS: gdb.base/printcmds.exp: p ctable1[201] +PASS: gdb.base/printcmds.exp: p ctable1[202] +PASS: gdb.base/printcmds.exp: p ctable1[203] +PASS: gdb.base/printcmds.exp: p ctable1[204] +PASS: gdb.base/printcmds.exp: p ctable1[205] +PASS: gdb.base/printcmds.exp: p ctable1[206] +PASS: gdb.base/printcmds.exp: p ctable1[207] +PASS: gdb.base/printcmds.exp: p ctable1[208] +PASS: gdb.base/printcmds.exp: p ctable1[209] +PASS: gdb.base/printcmds.exp: p ctable1[210] +PASS: gdb.base/printcmds.exp: p ctable1[211] +PASS: gdb.base/printcmds.exp: p ctable1[212] +PASS: gdb.base/printcmds.exp: p ctable1[213] +PASS: gdb.base/printcmds.exp: p ctable1[214] +PASS: gdb.base/printcmds.exp: p ctable1[215] +PASS: gdb.base/printcmds.exp: p ctable1[216] +PASS: gdb.base/printcmds.exp: p ctable1[217] +PASS: gdb.base/printcmds.exp: p ctable1[218] +PASS: gdb.base/printcmds.exp: p ctable1[219] +PASS: gdb.base/printcmds.exp: p ctable1[220] +PASS: gdb.base/printcmds.exp: p ctable1[221] +PASS: gdb.base/printcmds.exp: p ctable1[222] +PASS: gdb.base/printcmds.exp: p ctable1[223] +PASS: gdb.base/printcmds.exp: p ctable1[224] +PASS: gdb.base/printcmds.exp: p ctable1[225] +PASS: gdb.base/printcmds.exp: p ctable1[226] +PASS: gdb.base/printcmds.exp: p ctable1[227] +PASS: gdb.base/printcmds.exp: p ctable1[228] +PASS: gdb.base/printcmds.exp: p ctable1[229] +PASS: gdb.base/printcmds.exp: p ctable1[230] +PASS: gdb.base/printcmds.exp: p ctable1[231] +PASS: gdb.base/printcmds.exp: p ctable1[232] +PASS: gdb.base/printcmds.exp: p ctable1[233] +PASS: gdb.base/printcmds.exp: p ctable1[234] +PASS: gdb.base/printcmds.exp: p ctable1[235] +PASS: gdb.base/printcmds.exp: p ctable1[236] +PASS: gdb.base/printcmds.exp: p ctable1[237] +PASS: gdb.base/printcmds.exp: p ctable1[238] +PASS: gdb.base/printcmds.exp: p ctable1[239] +PASS: gdb.base/printcmds.exp: p ctable1[240] +PASS: gdb.base/printcmds.exp: p ctable1[241] +PASS: gdb.base/printcmds.exp: p ctable1[242] +PASS: gdb.base/printcmds.exp: p ctable1[243] +PASS: gdb.base/printcmds.exp: p ctable1[244] +PASS: gdb.base/printcmds.exp: p ctable1[245] +PASS: gdb.base/printcmds.exp: p ctable1[246] +PASS: gdb.base/printcmds.exp: p ctable1[247] +PASS: gdb.base/printcmds.exp: p ctable1[248] +PASS: gdb.base/printcmds.exp: p ctable1[249] +PASS: gdb.base/printcmds.exp: p ctable1[250] +PASS: gdb.base/printcmds.exp: p ctable1[251] +PASS: gdb.base/printcmds.exp: p ctable1[252] +PASS: gdb.base/printcmds.exp: p ctable1[253] +PASS: gdb.base/printcmds.exp: p ctable1[254] +PASS: gdb.base/printcmds.exp: p ctable1[255] +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 2 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: set print elements 3 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: set print elements 4 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 6 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: set print elements 7 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: set print elements 9 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: set print elements 10 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: set print elements 11 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: set print elements 12 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: set print elements 13 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: set print elements 14 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: set print elements 15 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: set print elements 16 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: correct element repeats in array embedded at offset > 0 +PASS: gdb.base/printcmds.exp: set print elements 0 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 0 +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 19 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 19 +PASS: gdb.base/printcmds.exp: set print elements 20 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 20 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable1[0] +PASS: gdb.base/printcmds.exp: p &ctable1[1] +PASS: gdb.base/printcmds.exp: p &ctable1[1*8] +PASS: gdb.base/printcmds.exp: p &ctable1[2*8] +PASS: gdb.base/printcmds.exp: p &ctable1[3*8] +PASS: gdb.base/printcmds.exp: p &ctable1[4*8] +PASS: gdb.base/printcmds.exp: p &ctable1[5*8] +PASS: gdb.base/printcmds.exp: p &ctable1[6*8] +PASS: gdb.base/printcmds.exp: p &ctable1[7*8] +PASS: gdb.base/printcmds.exp: p &ctable1[8*8] +PASS: gdb.base/printcmds.exp: p &ctable1[9*8] +PASS: gdb.base/printcmds.exp: p &ctable1[10*8] +PASS: gdb.base/printcmds.exp: p &ctable1[11*8] +PASS: gdb.base/printcmds.exp: p &ctable1[12*8] +PASS: gdb.base/printcmds.exp: p &ctable1[13*8] +PASS: gdb.base/printcmds.exp: p &ctable1[14*8] +PASS: gdb.base/printcmds.exp: p &ctable1[15*8] +PASS: gdb.base/printcmds.exp: p &ctable1[16*8] +PASS: gdb.base/printcmds.exp: p &ctable1[17*8] +PASS: gdb.base/printcmds.exp: p &ctable1[18*8] +PASS: gdb.base/printcmds.exp: p &ctable1[19*8] +PASS: gdb.base/printcmds.exp: p &ctable1[20*8] +PASS: gdb.base/printcmds.exp: p &ctable1[21*8] +PASS: gdb.base/printcmds.exp: p &ctable1[22*8] +PASS: gdb.base/printcmds.exp: p &ctable1[23*8] +PASS: gdb.base/printcmds.exp: p &ctable1[24*8] +PASS: gdb.base/printcmds.exp: p &ctable1[25*8] +PASS: gdb.base/printcmds.exp: p &ctable1[26*8] +PASS: gdb.base/printcmds.exp: p &ctable1[27*8] +PASS: gdb.base/printcmds.exp: p &ctable1[28*8] +PASS: gdb.base/printcmds.exp: p &ctable1[29*8] +PASS: gdb.base/printcmds.exp: p &ctable1[30*8] +PASS: gdb.base/printcmds.exp: p &ctable1[31*8] +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: p a1[0] +PASS: gdb.base/printcmds.exp: p a1[9] +PASS: gdb.base/printcmds.exp: p a2 +PASS: gdb.base/printcmds.exp: p a2[0] +PASS: gdb.base/printcmds.exp: p a2[3] +PASS: gdb.base/printcmds.exp: set print null-stop on +PASS: gdb.base/printcmds.exp: print a2 with null-stop on +PASS: gdb.base/printcmds.exp: set print null-stop off +PASS: gdb.base/printcmds.exp: p int1dim[0]@2 +PASS: gdb.base/printcmds.exp: p int1dim[0]@2@3 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print address on +PASS: gdb.base/printcmds.exp: p arrays +PASS: gdb.base/printcmds.exp: p parrays +PASS: gdb.base/printcmds.exp: p parrays->array1 +PASS: gdb.base/printcmds.exp: p &parrays->array1 +PASS: gdb.base/printcmds.exp: p parrays->array2 +PASS: gdb.base/printcmds.exp: p &parrays->array2 +PASS: gdb.base/printcmds.exp: p parrays->array3 +PASS: gdb.base/printcmds.exp: p &parrays->array3 +PASS: gdb.base/printcmds.exp: p parrays->array4 +PASS: gdb.base/printcmds.exp: p &parrays->array4 +PASS: gdb.base/printcmds.exp: p parrays->array5 +PASS: gdb.base/printcmds.exp: p &parrays->array5 +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set print elements 50 +PASS: gdb.base/printcmds.exp: p "a string" +PASS: gdb.base/printcmds.exp: p "embedded \000 null" +PASS: gdb.base/printcmds.exp: p "abcd"[2] +PASS: gdb.base/printcmds.exp: p sizeof ("abcdef") +PASS: gdb.base/printcmds.exp: ptype "foo" +PASS: gdb.base/printcmds.exp: p *"foo" +PASS: gdb.base/printcmds.exp: ptype *"foo" +PASS: gdb.base/printcmds.exp: p &*"foo" +PASS: gdb.base/printcmds.exp: ptype &*"foo" +PASS: gdb.base/printcmds.exp: p (char *)"foo" +PASS: gdb.base/printcmds.exp: print {'a','b','c'} +PASS: gdb.base/printcmds.exp: print {4,5,6}[2] +PASS: gdb.base/printcmds.exp: print *&{4,5,6}[1] +PASS: gdb.base/printcmds.exp: print some_volatile_enum +PASS: gdb.base/printcmds.exp: print three +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%d,z=%d\n", 5, 6, 7 +PASS: gdb.base/printcmds.exp: printf "string=%.4sxx\n", teststring +PASS: gdb.base/printcmds.exp: printf "string=%sxx\n", teststring +PASS: gdb.base/printcmds.exp: printf "%f is fun\n", 1.0 +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%f,z=%d\n", 5, 6.0, 7 +PASS: gdb.base/printcmds.exp: printf "%x %f, %c %x, %x, %f\n", 0xbad, -99.541, 'z', 0xfeedface, 0xdeadbeef, 5.0 +PASS: gdb.base/printcmds.exp: printf "%c\n", "x"[1,0] +PASS: gdb.base/printcmds.exp: printf "%%%d%%\n", 5 +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E1df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E-10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E96df +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E1dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E-10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E384dd +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E1dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E-10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E6144dl +PASS: gdb.base/printcmds.exp: printf "%Hf %Hf\n",1.2df,1.3df +PASS: gdb.base/printcmds.exp: set print symbol on +PASS: gdb.base/printcmds.exp: print &three +PASS: gdb.base/printcmds.exp: print parrays +PASS: gdb.base/printcmds.exp: set print symbol off +PASS: gdb.base/printcmds.exp: print invalid_LLL +PASS: gdb.base/printcmds.exp: print invalid_LLE +PASS: gdb.base/printcmds.exp: print invalid_LLR +PASS: gdb.base/printcmds.exp: print invalid_LLS +PASS: gdb.base/printcmds.exp: print invalid_ELL +PASS: gdb.base/printcmds.exp: print invalid_ELR +PASS: gdb.base/printcmds.exp: print invalid_ELS +PASS: gdb.base/printcmds.exp: print invalid_RLL +PASS: gdb.base/printcmds.exp: print invalid_RLE +PASS: gdb.base/printcmds.exp: print invalid_RLR +PASS: gdb.base/printcmds.exp: print invalid_RLS +PASS: gdb.base/printcmds.exp: print invalid_SLL +PASS: gdb.base/printcmds.exp: print invalid_SLE +PASS: gdb.base/printcmds.exp: print invalid_SLR +PASS: gdb.base/printcmds.exp: print invalid_SLS +PASS: gdb.base/printcmds.exp: print invalid_LRL +PASS: gdb.base/printcmds.exp: print invalid_LRE +PASS: gdb.base/printcmds.exp: print invalid_LRR +PASS: gdb.base/printcmds.exp: print invalid_LRS +PASS: gdb.base/printcmds.exp: print invalid_ERL +PASS: gdb.base/printcmds.exp: print invalid_ERR +PASS: gdb.base/printcmds.exp: print invalid_ERS +PASS: gdb.base/printcmds.exp: print invalid_RRL +PASS: gdb.base/printcmds.exp: print invalid_RRE +PASS: gdb.base/printcmds.exp: print invalid_RRR +PASS: gdb.base/printcmds.exp: print invalid_RRS +PASS: gdb.base/printcmds.exp: print invalid_SRL +PASS: gdb.base/printcmds.exp: print invalid_SRE +PASS: gdb.base/printcmds.exp: print invalid_SRR +PASS: gdb.base/printcmds.exp: print invalid_SRS +PASS: gdb.base/printcmds.exp: print invalid_LSL +PASS: gdb.base/printcmds.exp: print invalid_LSE +PASS: gdb.base/printcmds.exp: print invalid_LSR +PASS: gdb.base/printcmds.exp: print invalid_LSS +PASS: gdb.base/printcmds.exp: print invalid_ESL +PASS: gdb.base/printcmds.exp: print invalid_ESR +PASS: gdb.base/printcmds.exp: print invalid_ESS +PASS: gdb.base/printcmds.exp: print invalid_RSL +PASS: gdb.base/printcmds.exp: print invalid_RSE +PASS: gdb.base/printcmds.exp: print invalid_RSR +PASS: gdb.base/printcmds.exp: print invalid_RSS +PASS: gdb.base/printcmds.exp: print invalid_SSL +PASS: gdb.base/printcmds.exp: print invalid_SSE +PASS: gdb.base/printcmds.exp: print invalid_SSR +PASS: gdb.base/printcmds.exp: print invalid_SSS +Running ./gdb.base/print-file-var.exp ... +PASS: gdb.base/print-file-var.exp: breapoint past v1 & v2 initialization +PASS: gdb.base/print-file-var.exp: continue to STOP marker +PASS: gdb.base/print-file-var.exp: print 'print-file-var-lib1.c'::this_version_id == v1 +PASS: gdb.base/print-file-var.exp: print 'print-file-var-lib2.c'::this_version_id == v2 +Running ./gdb.base/prologue.exp ... +PASS: gdb.base/prologue.exp: setting breakpoint at marker +PASS: gdb.base/prologue.exp: continue to marker +PASS: gdb.base/prologue.exp: reading $pc: marker +PASS: gdb.base/prologue.exp: setting breakpoint at other +PASS: gdb.base/prologue.exp: continue to other +PASS: gdb.base/prologue.exp: reading $pc: other +PASS: gdb.base/prologue.exp: same pc from minimal symbol +Running ./gdb.base/prologue-include.exp ... +PASS: gdb.base/prologue-include.exp: breakpoint main +Running ./gdb.base/psymtab.exp ... +PASS: gdb.base/psymtab.exp: psymtab pending setup +PASS: gdb.base/psymtab.exp: Don't search past end of psymtab. +Running ./gdb.base/ptr-typedef.exp ... +PASS: gdb.base/ptr-typedef.exp: print foo_ptr +PASS: gdb.base/ptr-typedef.exp: print foz_ptr +Running ./gdb.base/ptype.exp ... +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member +PASS: gdb.base/ptype.exp: ptype structure +PASS: gdb.base/ptype.exp: ptype v_struct1.v_float_member +PASS: gdb.base/ptype.exp: ptype v_struct1->v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p.v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p->v_float_member +PASS: gdb.base/ptype.exp: ptype linked list structure +PASS: gdb.base/ptype.exp: ptype union +PASS: gdb.base/ptype.exp: ptype linked list union +PASS: gdb.base/ptype.exp: ptype unnamed enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration +PASS: gdb.base/ptype.exp: ptype unnamed typedef'd enumeration +PASS: gdb.base/ptype.exp: list main +PASS: gdb.base/ptype.exp: whatis unnamed typedef'd enum (compiler bug in IBM's xlc) +PASS: gdb.base/ptype.exp: printing typedef'd struct +PASS: gdb.base/ptype.exp: printing typedef'd union +PASS: gdb.base/ptype.exp: ptype named typedef'd enumf'd enum +PASS: gdb.base/ptype.exp: ptype misordered enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration member +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member #2 +PASS: gdb.base/ptype.exp: ptype short +PASS: gdb.base/ptype.exp: ptype int +PASS: gdb.base/ptype.exp: ptype t_char_array +PASS: gdb.base/ptype.exp: ptype pv_char_array +PASS: gdb.base/ptype.exp: ptype outer structure +PASS: gdb.base/ptype.exp: ptype inner structure +PASS: gdb.base/ptype.exp: ptype inner union +PASS: gdb.base/ptype.exp: ptype nested structure +PASS: gdb.base/ptype.exp: ptype outer int +PASS: gdb.base/ptype.exp: ptype nested structure #2 +PASS: gdb.base/ptype.exp: ptype inner int +PASS: gdb.base/ptype.exp: ptype nested union +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype func_type +PASS: gdb.base/ptype.exp: ptype old_fptr +PASS: gdb.base/ptype.exp: ptype new_fptr +PASS: gdb.base/ptype.exp: ptype fptr +PASS: gdb.base/ptype.exp: ptype fptr2 +PASS: gdb.base/ptype.exp: ptype xptr +PASS: gdb.base/ptype.exp: ptype ffptr +PASS: gdb.base/ptype.exp: ptype fffptr +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of charfoo +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of charfoo +PASS: gdb.base/ptype.exp: ptype "abc" +PASS: gdb.base/ptype.exp: ptype {'a','b','c'} +PASS: gdb.base/ptype.exp: ptype {0,1,2} +PASS: gdb.base/ptype.exp: ptype {(long)0,(long)1,(long)2} +PASS: gdb.base/ptype.exp: ptype {(float)0,(float)1,(float)2} +PASS: gdb.base/ptype.exp: ptype {{0,1,2},{3,4,5}} +PASS: gdb.base/ptype.exp: ptype {4,5,6}[2] +PASS: gdb.base/ptype.exp: ptype *&{4,5,6}[1] +PASS: gdb.base/ptype.exp: ptype $pc +Running ./gdb.base/radix.exp ... +PASS: gdb.base/radix.exp: initialize radix, input radix 2 +PASS: gdb.base/radix.exp: set input-radix 2 +PASS: gdb.base/radix.exp: show radix, input radix 2 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 2 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 2 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 2 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 2 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 2 +PASS: gdb.base/radix.exp: print 10; expect 2; input radix 2 +PASS: gdb.base/radix.exp: print 11; expect 3; input radix 2 +PASS: gdb.base/radix.exp: print -10; expect -2; input radix 2 +PASS: gdb.base/radix.exp: print -11; expect -3; input radix 2 +PASS: gdb.base/radix.exp: print 100; expect 4; input radix 2 +PASS: gdb.base/radix.exp: print 101; expect 5; input radix 2 +PASS: gdb.base/radix.exp: print -100; expect -4; input radix 2 +PASS: gdb.base/radix.exp: print -101; expect -5; input radix 2 +PASS: gdb.base/radix.exp: print 10101; expect 21; input radix 2 +PASS: gdb.base/radix.exp: print 4; expect Invalid number "4"\.; input radix 2 +PASS: gdb.base/radix.exp: print -2; expect Invalid number "2"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 3 +PASS: gdb.base/radix.exp: set input-radix 3 +PASS: gdb.base/radix.exp: show radix, input radix 3 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 3 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 3 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 3 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 3 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 3 +PASS: gdb.base/radix.exp: print 10; expect 3; input radix 3 +PASS: gdb.base/radix.exp: print 11; expect 4; input radix 3 +PASS: gdb.base/radix.exp: print -10; expect -3; input radix 3 +PASS: gdb.base/radix.exp: print -11; expect -4; input radix 3 +PASS: gdb.base/radix.exp: print 100; expect 9; input radix 3 +PASS: gdb.base/radix.exp: print 101; expect 10; input radix 3 +PASS: gdb.base/radix.exp: print -100; expect -9; input radix 3 +PASS: gdb.base/radix.exp: print -101; expect -10; input radix 3 +PASS: gdb.base/radix.exp: print 10101; expect 91; input radix 3 +PASS: gdb.base/radix.exp: print 2; expect 2; input radix 3 +PASS: gdb.base/radix.exp: print 20; expect 6; input radix 3 +PASS: gdb.base/radix.exp: print 3; expect Invalid number "3"\.; input radix 3 +PASS: gdb.base/radix.exp: print 30; expect Invalid number "30"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 8 +PASS: gdb.base/radix.exp: set input-radix 8 +PASS: gdb.base/radix.exp: show radix, input radix 8 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 8 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 8 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 8 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 8 +PASS: gdb.base/radix.exp: print 10; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 11; expect 9; input radix 8 +PASS: gdb.base/radix.exp: print -10; expect -8; input radix 8 +PASS: gdb.base/radix.exp: print -11; expect -9; input radix 8 +PASS: gdb.base/radix.exp: print 100; expect 64; input radix 8 +PASS: gdb.base/radix.exp: print 101; expect 65; input radix 8 +PASS: gdb.base/radix.exp: print -100; expect -64; input radix 8 +PASS: gdb.base/radix.exp: print -101; expect -65; input radix 8 +PASS: gdb.base/radix.exp: print 10101; expect 4161; input radix 8 +PASS: gdb.base/radix.exp: print 20; expect 16; input radix 8 +PASS: gdb.base/radix.exp: print -20; expect -16; input radix 8 +PASS: gdb.base/radix.exp: print 8; expect Invalid number "8".; input radix 8 +PASS: gdb.base/radix.exp: print -9; expect Invalid number "9".; input radix 8 +PASS: gdb.base/radix.exp: initialize radix, input radix 10 +PASS: gdb.base/radix.exp: set input-radix 10 +PASS: gdb.base/radix.exp: show radix, input radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 10 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 10 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 10 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; input radix 10 +PASS: gdb.base/radix.exp: print 11; expect 11; input radix 10 +PASS: gdb.base/radix.exp: print -10; expect -10; input radix 10 +PASS: gdb.base/radix.exp: print -11; expect -11; input radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; input radix 10 +PASS: gdb.base/radix.exp: print 101; expect 101; input radix 10 +PASS: gdb.base/radix.exp: print -100; expect -100; input radix 10 +PASS: gdb.base/radix.exp: print -101; expect -101; input radix 10 +PASS: gdb.base/radix.exp: print 10101; expect 10101; input radix 10 +PASS: gdb.base/radix.exp: print -12; expect -12; input radix 10 +PASS: gdb.base/radix.exp: initialize radix, input radix 16 +PASS: gdb.base/radix.exp: set input-radix 16 +PASS: gdb.base/radix.exp: show radix, input radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 16 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 16 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 16 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 16 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 16 +PASS: gdb.base/radix.exp: print 10; expect 16; input radix 16 +PASS: gdb.base/radix.exp: print 11; expect 17; input radix 16 +PASS: gdb.base/radix.exp: print -10; expect -16; input radix 16 +PASS: gdb.base/radix.exp: print -11; expect -17; input radix 16 +PASS: gdb.base/radix.exp: print 100; expect 256; input radix 16 +PASS: gdb.base/radix.exp: print 101; expect 257; input radix 16 +PASS: gdb.base/radix.exp: print -100; expect -256; input radix 16 +PASS: gdb.base/radix.exp: print -101; expect -257; input radix 16 +PASS: gdb.base/radix.exp: print 10101; expect 65793; input radix 16 +PASS: gdb.base/radix.exp: initialize radix, output radix 8 +PASS: gdb.base/radix.exp: set output-radix 8 +PASS: gdb.base/radix.exp: show radix, output radix 8 +PASS: gdb.base/radix.exp: print 010; expect 010; output radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 17; output radix 8 +PASS: gdb.base/radix.exp: print 10; expect 12; output radix 8 +PASS: gdb.base/radix.exp: print 100; expect 144; output radix 8 +KFAIL: gdb.base/radix.exp: print 20.; expect 24; output radix 8 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 24; output radix 8 +PASS: gdb.base/radix.exp: initialize radix, output radix 10 +PASS: gdb.base/radix.exp: set output-radix 10 +PASS: gdb.base/radix.exp: show radix, output radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; output radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; output radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; output radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: initialize radix, output radix 16 +PASS: gdb.base/radix.exp: set output-radix 16 +PASS: gdb.base/radix.exp: show radix, output radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect f; output radix 16 +PASS: gdb.base/radix.exp: print 10; expect a; output radix 16 +PASS: gdb.base/radix.exp: print 100; expect 64; output radix 16 +KFAIL: gdb.base/radix.exp: print 20.; expect 14; output radix 16 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 14; output radix 16 +PASS: gdb.base/radix.exp: Reset radices +PASS: gdb.base/radix.exp: Reject input-radix 0 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject input-radix 1 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: Reject output-radix 0 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject output-radix 1 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: set radix 7 rejected +PASS: gdb.base/radix.exp: Output radix unchanged after rejection through set radix command +Running ./gdb.base/randomize.exp ... +UNTESTED: gdb.base/randomize.exp: Disabling randomization is not supported on this Linux GDB +Running ./gdb.base/random-signal.exp ... +PASS: gdb.base/random-signal.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/random-signal.exp: watch v +PASS: gdb.base/random-signal.exp: continue +FAIL: gdb.base/random-signal.exp: stop with control-c +Running ./gdb.base/readline-ask.exp ... +PASS: gdb.base/readline-ask.exp: set width 50 +PASS: gdb.base/readline-ask.exp: set height 3 +PASS: gdb.base/readline-ask.exp: bell for more message +FAIL: gdb.base/readline-ask.exp: more message for 01 and 02 +FAIL: gdb.base/readline-ask.exp: more message for 03 +FAIL: gdb.base/readline-ask.exp: more finish for 04 +ERROR: Undefined command "foo". +UNRESOLVED: gdb.base/readline-ask.exp: abort more message +PASS: gdb.base/readline-ask.exp: bell for ask message +FAIL: gdb.base/readline-ask.exp: ask message +Running ./gdb.base/readline.exp ... +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - final prompt +PASS: gdb.base/readline.exp: print 42 +PASS: gdb.base/readline.exp: arrow keys with secondary prompt +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +Running ./gdb.base/realname-expand.exp ... +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: rbreak realname-expand-real.c:func +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: break realname-expand-real.c:func +Running ./gdb.base/recpar.exp ... +PASS: gdb.base/recpar.exp: break recpar.c:26 if n == 3 +PASS: gdb.base/recpar.exp: continue +PASS: gdb.base/recpar.exp: backtrace +PASS: gdb.base/recpar.exp: frame 2 +PASS: gdb.base/recpar.exp: print foo::val +Running ./gdb.base/recurse.exp ... +PASS: gdb.base/recurse.exp: next over b = 0 in first instance +PASS: gdb.base/recurse.exp: set first instance watchpoint +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 9) +PASS: gdb.base/recurse.exp: continue to recurse (a = 8) +PASS: gdb.base/recurse.exp: continue to recurse (a = 7) +PASS: gdb.base/recurse.exp: continue to recurse (a = 6) +PASS: gdb.base/recurse.exp: continue to recurse (a = 5) +PASS: gdb.base/recurse.exp: next over b = 0 in second instance +PASS: gdb.base/recurse.exp: set second instance watchpoint +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 4) +PASS: gdb.base/recurse.exp: continue to recurse (a = 3) +PASS: gdb.base/recurse.exp: continue to recurse (a = 2) +PASS: gdb.base/recurse.exp: continue to recurse (a = 1) +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, second time +PASS: gdb.base/recurse.exp: second instance watchpoint deleted when leaving scope +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, second time +PASS: gdb.base/recurse.exp: first instance watchpoint deleted when leaving scope +Running ./gdb.base/relational.exp ... +PASS: gdb.base/relational.exp: set variable x=14 +PASS: gdb.base/relational.exp: set variable y=2 +PASS: gdb.base/relational.exp: set variable z=2 +PASS: gdb.base/relational.exp: set variable w=3 +PASS: gdb.base/relational.exp: print value of x +PASS: gdb.base/relational.exp: print value of y +PASS: gdb.base/relational.exp: print value of z +PASS: gdb.base/relational.exp: print value of w +PASS: gdb.base/relational.exp: print value of x<y +PASS: gdb.base/relational.exp: print value of x<=y +PASS: gdb.base/relational.exp: print value of x>y +PASS: gdb.base/relational.exp: print value of x>=y +PASS: gdb.base/relational.exp: print value of x==y +PASS: gdb.base/relational.exp: print value of x!=y +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<z +PASS: gdb.base/relational.exp: print value of x<=y<=z +PASS: gdb.base/relational.exp: print value of x>y>z +PASS: gdb.base/relational.exp: print value of x>=y>=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x==y==z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x!=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y==z +PASS: gdb.base/relational.exp: print value of x<y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<=z +PASS: gdb.base/relational.exp: print value of x<y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y>z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y!=z +PASS: gdb.base/relational.exp: set x to 4 +PASS: gdb.base/relational.exp: print value of x>y<=z +PASS: gdb.base/relational.exp: print value of x>=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=y<=z +PASS: gdb.base/relational.exp: print value of x<=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x<=y!=z +PASS: gdb.base/relational.exp: print value of x==y!=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=(y<z) +PASS: gdb.base/relational.exp: print value of x>=(y!=z) +PASS: gdb.base/relational.exp: print value of x==(y==z) +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of (x==y)<z +Running ./gdb.base/relativedebug.exp ... +PASS: gdb.base/relativedebug.exp: continue +PASS: gdb.base/relativedebug.exp: pause found in backtrace +Running ./gdb.base/relocate.exp ... +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o 0 +PASS: gdb.base/relocate.exp: get address of static_foo +PASS: gdb.base/relocate.exp: get address of static_bar +PASS: gdb.base/relocate.exp: static variables have different addresses +PASS: gdb.base/relocate.exp: get address of global_foo +PASS: gdb.base/relocate.exp: get address of global_bar +PASS: gdb.base/relocate.exp: global variables have different addresses +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: get address of function_bar +PASS: gdb.base/relocate.exp: functions have different addresses +PASS: gdb.base/relocate.exp: set $offset = 0x10000 +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o $offset +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: function foo has a different address +PASS: gdb.base/relocate.exp: print static_foo +PASS: gdb.base/relocate.exp: print static_bar +PASS: gdb.base/relocate.exp: print global_foo +PASS: gdb.base/relocate.exp: print global_bar +Running ./gdb.base/remote.exp ... +PASS: gdb.base/remote.exp: write-packet default +PASS: gdb.base/remote.exp: set write-packet - NULL +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 20 +PASS: gdb.base/remote.exp: set write-packet - small +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 1 +PASS: gdb.base/remote.exp: set write-packet - very-small +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set write size class +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 16385 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 +PASS: gdb.base/remote.exp: get integer valueof "sizeof (random_data)" (49152) +PASS: gdb.base/remote.exp: x/8ub random_data +PASS: gdb.base/remote.exp: x/8ub random_data + 400 - 4 +PASS: gdb.base/remote.exp: x/8ub random_data + 16384 - 4 +PASS: gdb.base/remote.exp: set remote memory-read-packet-size 16 +PASS: gdb.base/remote.exp: show remote memory-read-packet-size +PASS: gdb.base/remote.exp: x/17ub random_data +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit 2147483647 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit 2147483647 +Running ./gdb.base/remotetimeout.exp ... +Running ./gdb.base/reread.exp ... +PASS: gdb.base/reread.exp: breakpoint foo in first file +PASS: gdb.base/reread.exp: run to foo() +UNSUPPORTED: gdb.base/reread.exp: run to foo() second time +UNSUPPORTED: gdb.base/reread.exp: second pass: GDB should check for changes before running +Running ./gdb.base/restore.exp ... +PASS: gdb.base/restore.exp: tbreak caller1 +PASS: gdb.base/restore.exp: run to caller1 +PASS: gdb.base/restore.exp: caller1 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: tbreak caller2 +PASS: gdb.base/restore.exp: run to caller2 +PASS: gdb.base/restore.exp: caller2 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee1; return callee now +FAIL: gdb.base/restore.exp: caller2 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee2; return callee now +FAIL: gdb.base/restore.exp: caller2 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee3; return callee now +FAIL: gdb.base/restore.exp: caller2 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee4; return callee now +FAIL: gdb.base/restore.exp: caller2 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee5; return callee now +FAIL: gdb.base/restore.exp: caller2 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: tbreak caller3 +PASS: gdb.base/restore.exp: run to caller3 +PASS: gdb.base/restore.exp: caller3 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee1; return callee now +FAIL: gdb.base/restore.exp: caller3 calls callee1; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller3 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee2; return callee now +FAIL: gdb.base/restore.exp: caller3 calls callee2; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller3 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee3; return callee now +FAIL: gdb.base/restore.exp: caller3 calls callee3; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller3 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee4; return callee now +FAIL: gdb.base/restore.exp: caller3 calls callee4; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller3 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee5; return callee now +FAIL: gdb.base/restore.exp: caller3 calls callee5; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller3 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: tbreak caller4 +PASS: gdb.base/restore.exp: run to caller4 +PASS: gdb.base/restore.exp: caller4 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee1; return callee now +FAIL: gdb.base/restore.exp: caller4 calls callee1; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller4 calls callee1; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller4 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee2; return callee now +FAIL: gdb.base/restore.exp: caller4 calls callee2; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller4 calls callee2; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller4 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee3; return callee now +FAIL: gdb.base/restore.exp: caller4 calls callee3; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller4 calls callee3; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller4 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee4; return callee now +FAIL: gdb.base/restore.exp: caller4 calls callee4; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller4 calls callee4; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller4 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee5; return callee now +FAIL: gdb.base/restore.exp: caller4 calls callee5; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller4 calls callee5; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller4 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: tbreak caller5 +PASS: gdb.base/restore.exp: run to caller5 +PASS: gdb.base/restore.exp: caller5 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee1; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee1; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller5 calls callee1; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller5 calls callee1; return restored l3 to 32494 +FAIL: gdb.base/restore.exp: caller5 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee2; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee2; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller5 calls callee2; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller5 calls callee2; return restored l3 to 32494 +FAIL: gdb.base/restore.exp: caller5 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee3; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee3; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller5 calls callee3; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller5 calls callee3; return restored l3 to 32494 +FAIL: gdb.base/restore.exp: caller5 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee4; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee4; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller5 calls callee4; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller5 calls callee4; return restored l3 to 32494 +FAIL: gdb.base/restore.exp: caller5 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee5; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee5; return restored l1 to 32492 +FAIL: gdb.base/restore.exp: caller5 calls callee5; return restored l2 to 32493 +FAIL: gdb.base/restore.exp: caller5 calls callee5; return restored l3 to 32494 +FAIL: gdb.base/restore.exp: caller5 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l5 to 32496 +Running ./gdb.base/return2.exp ... +PASS: gdb.base/return2.exp: set break on void_func +PASS: gdb.base/return2.exp: continue to void_func +PASS: gdb.base/return2.exp: return from void_func +PASS: gdb.base/return2.exp: void function returned successfully +PASS: gdb.base/return2.exp: set break on char_func +PASS: gdb.base/return2.exp: continue to char_func +PASS: gdb.base/return2.exp: return from char_func +PASS: gdb.base/return2.exp: char value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on short_func +PASS: gdb.base/return2.exp: continue to short_func +PASS: gdb.base/return2.exp: return from short_func +PASS: gdb.base/return2.exp: short value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on int_func +PASS: gdb.base/return2.exp: continue to int_func +PASS: gdb.base/return2.exp: return from int_func +PASS: gdb.base/return2.exp: int value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_func +PASS: gdb.base/return2.exp: continue to long_func +PASS: gdb.base/return2.exp: return from long_func +PASS: gdb.base/return2.exp: long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_long_func +PASS: gdb.base/return2.exp: continue to long_long_func +PASS: gdb.base/return2.exp: return from long_long_func +PASS: gdb.base/return2.exp: long_long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on float_func +PASS: gdb.base/return2.exp: continue to float_func +PASS: gdb.base/return2.exp: return from float_func +PASS: gdb.base/return2.exp: float value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on double_func +PASS: gdb.base/return2.exp: continue to double_func +PASS: gdb.base/return2.exp: return from double_func +PASS: gdb.base/return2.exp: double value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +Running ./gdb.base/return.exp ... +PASS: gdb.base/return.exp: simple return +PASS: gdb.base/return.exp: break func2 +PASS: gdb.base/return.exp: break func3 +PASS: gdb.base/return.exp: continue to return of -5 +PASS: gdb.base/return.exp: next over call to func2 +PASS: gdb.base/return.exp: correct value returned (integer test) +PASS: gdb.base/return.exp: continue to return of -5.0 +PASS: gdb.base/return.exp: next over call to func3 +PASS: gdb.base/return.exp: correct value returned double test (known problem with sparc solaris) +Running ./gdb.base/return-nodebug.exp ... +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: signed-char: advance to marker +PASS: gdb.base/return-nodebug.exp: signed-char: full width of the returned result +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: short: advance to marker +PASS: gdb.base/return-nodebug.exp: short: full width of the returned result +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: int: advance to marker +PASS: gdb.base/return-nodebug.exp: int: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long: advance to marker +PASS: gdb.base/return-nodebug.exp: long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long-long: advance to marker +PASS: gdb.base/return-nodebug.exp: long-long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: float: advance to marker +PASS: gdb.base/return-nodebug.exp: float: full width of the returned result +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: double: advance to marker +PASS: gdb.base/return-nodebug.exp: double: full width of the returned result +Running ./gdb.base/save-bp.exp ... +PASS: gdb.base/save-bp.exp: add breakpoint commands +PASS: gdb.base/save-bp.exp: dprintf save-bp.c:33,"At foo entry\n" +PASS: gdb.base/save-bp.exp: save breakpoint bps +PASS: gdb.base/save-bp.exp: source bps +PASS: gdb.base/save-bp.exp: info break +Running ./gdb.base/savedregs.exp ... +PASS: gdb.base/savedregs.exp: advance thrower +PASS: gdb.base/savedregs.exp: Get main info frame +PASS: gdb.base/savedregs.exp: handle SIGSEGV pass print nostop +PASS: gdb.base/savedregs.exp: handle SIGILL pass print nostop +PASS: gdb.base/savedregs.exp: advance catcher +PASS: gdb.base/savedregs.exp: Get sigtramp info frame +PASS: gdb.base/savedregs.exp: Get thrower info frame +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: break caller +PASS: gdb.base/savedregs.exp: call caller (1,2,3,4,5,6,7,8) +PASS: gdb.base/savedregs.exp: Get dummy info frame +PASS: gdb.base/savedregs.exp: Get catcher info frame +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: advance callee +PASS: gdb.base/savedregs.exp: Get caller info frame +PASS: gdb.base/savedregs.exp: Check dummy info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check catcher info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains callee caller dummy catcher sigtramp thrower main +Running ./gdb.base/scope.exp ... +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +UNSUPPORTED: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss before run +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal before run +PASS: gdb.base/scope.exp: next over init0() in main +PASS: gdb.base/scope.exp: print filelocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at main +PASS: gdb.base/scope.exp: print filelocal_bss +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_main +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_main +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro +PASS: gdb.base/scope.exp: print foo::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal +PASS: gdb.base/scope.exp: print foo::funclocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro +PASS: gdb.base/scope.exp: print bar::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print filelocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at foo +PASS: gdb.base/scope.exp: print filelocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at foo +PASS: gdb.base/scope.exp: print filelocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at foo +PASS: gdb.base/scope.exp: print funclocal at foo +PASS: gdb.base/scope.exp: print foo::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at foo +PASS: gdb.base/scope.exp: print funclocal_bss at foo +PASS: gdb.base/scope.exp: print foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print funclocal_ro at foo +PASS: gdb.base/scope.exp: print foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print filelocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at bar +PASS: gdb.base/scope.exp: print filelocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at bar +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print foo::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at bar +PASS: gdb.base/scope.exp: print foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print funclocal at bar +PASS: gdb.base/scope.exp: print bar::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at bar +PASS: gdb.base/scope.exp: print funclocal_bss at bar +PASS: gdb.base/scope.exp: print bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: continue to marker2 +PASS: gdb.base/scope.exp: up from marker2 in scopes.exp +PASS: gdb.base/scope.exp: print localval, outer scope +PASS: gdb.base/scope.exp: print localval1, outer scope +PASS: gdb.base/scope.exp: print localval2, outer scope +PASS: gdb.base/scope.exp: print localval3, outer scope +PASS: gdb.base/scope.exp: continue to marker3 in scope.exp +PASS: gdb.base/scope.exp: up from marker3 in scope.exp +PASS: gdb.base/scope.exp: print localval, first nested scope +PASS: gdb.base/scope.exp: print localval1, first nested scope +PASS: gdb.base/scope.exp: print localval2, first nested scope +PASS: gdb.base/scope.exp: print localval3, first nested scope +PASS: gdb.base/scope.exp: continue to marker4 in scope.exp +PASS: gdb.base/scope.exp: up from marker4 in scope.exp +PASS: gdb.base/scope.exp: print localval, innermost scope +PASS: gdb.base/scope.exp: print localval1, innermost scope +PASS: gdb.base/scope.exp: print localval2, innermost scope +PASS: gdb.base/scope.exp: print localval3, innermost scope +PASS: gdb.base/scope.exp: continue to marker1 +PASS: gdb.base/scope.exp: up from marker1 in scope.exp +PASS: gdb.base/scope.exp: 100 auto variables correctly initialized +PASS: gdb.base/scope.exp: args in correct order +Running ./gdb.base/sect-cmd.exp ... +Running ./gdb.base/sepdebug.exp ... +PASS: gdb.base/sepdebug.exp: breakpoint function +PASS: gdb.base/sepdebug.exp: breakpoint quoted function +PASS: gdb.base/sepdebug.exp: breakpoint function in file +PASS: gdb.base/sepdebug.exp: use `list' to establish default source file +PASS: gdb.base/sepdebug.exp: breakpoint line number +PASS: gdb.base/sepdebug.exp: breakpoint duplicate +PASS: gdb.base/sepdebug.exp: breakpoint line number in file +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line while conditional +PASS: gdb.base/sepdebug.exp: breakpoint info +PASS: gdb.base/sepdebug.exp: run until function breakpoint +PASS: gdb.base/sepdebug.exp: run until breakpoint set at a line number +PASS: gdb.base/sepdebug.exp: run until file:function(6) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(5) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(4) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(3) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(2) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(1) breakpoint +PASS: gdb.base/sepdebug.exp: run until quoted breakpoint +PASS: gdb.base/sepdebug.exp: run until file:linenum breakpoint +PASS: gdb.base/sepdebug.exp: breakpoint offset +1 +PASS: gdb.base/sepdebug.exp: step onto breakpoint +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function in file +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #2 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #2 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint info +PASS: gdb.base/sepdebug.exp: catch requires an event name +PASS: gdb.base/sepdebug.exp: set catch fork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch vfork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch exec, never expected to trigger +PASS: gdb.base/sepdebug.exp: set breakpoint pending off +PASS: gdb.base/sepdebug.exp: break on non-existent source line +PASS: gdb.base/sepdebug.exp: until bp_location1 +PASS: gdb.base/sepdebug.exp: break on default location, 1st time +PASS: gdb.base/sepdebug.exp: break on default location, 2nd time +PASS: gdb.base/sepdebug.exp: break on default location, 3rd time +PASS: gdb.base/sepdebug.exp: break on default location, 4th time +PASS: gdb.base/sepdebug.exp: set to-be-silent break bp_location1 +PASS: gdb.base/sepdebug.exp: set silent break bp_location1 +PASS: gdb.base/sepdebug.exp: info silent break bp_location1 +PASS: gdb.base/sepdebug.exp: hit silent break bp_location1 +PASS: gdb.base/sepdebug.exp: stopped for silent break bp_location1 +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/sepdebug.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/sepdebug.exp: step over breakpoint +PASS: gdb.base/sepdebug.exp: clear line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: break marker3 #1 +PASS: gdb.base/sepdebug.exp: break marker3 #2 +PASS: gdb.base/sepdebug.exp: clear marker3 +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/sepdebug.exp: set breakpoint via convenience variable +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/sepdebug.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/sepdebug.exp: set breakpoint on to-be-called function +PASS: gdb.base/sepdebug.exp: hit breakpoint on called function +PASS: gdb.base/sepdebug.exp: backtrace while in called function +PASS: gdb.base/sepdebug.exp: finish from called function +PASS: gdb.base/sepdebug.exp: finish with arguments disallowed +PASS: gdb.base/sepdebug.exp: finish from outermost frame disallowed +PASS: gdb.base/sepdebug.exp: kill program +PASS: gdb.base/sepdebug.exp: break at factorial +PASS: gdb.base/sepdebug.exp: continue to factorial(5) +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5) +PASS: gdb.base/sepdebug.exp: next to recursive call +PASS: gdb.base/sepdebug.exp: next over recursive call +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5.1) +PASS: gdb.base/sepdebug.exp: continue until exit at recursive next test +PASS: gdb.base/sepdebug.exp: debuglink: set separate debug location +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: CRC mismatch is reported +PASS: gdb.base/sepdebug.exp: build-id support by binutils +PASS: gdb.base/sepdebug.exp: build-id: set separate debug location +PASS: gdb.base/sepdebug.exp: build-id: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: build-id: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: set separate debug location +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until breakpoint set at small function, optimized file +Running ./gdb.base/sep.exp ... +PASS: gdb.base/sep.exp: list using location inside included file +PASS: gdb.base/sep.exp: breakpoint inside included file +Running ./gdb.base/sepsymtab.exp ... +PASS: gdb.base/sepsymtab.exp: info sym main +Running ./gdb.base/set-lang-auto.exp ... +PASS: gdb.base/set-lang-auto.exp: show lang after loading binary +PASS: gdb.base/set-lang-auto.exp: forcing the language to ada +PASS: gdb.base/set-lang-auto.exp: show lang after switching language to ada +PASS: gdb.base/set-lang-auto.exp: switching the language back to auto +PASS: gdb.base/set-lang-auto.exp: show lang after having switched back to auto +Running ./gdb.base/set-noassign.exp ... +PASS: gdb.base/set-noassign.exp: set language ada +PASS: gdb.base/set-noassign.exp: warning for set without assignment +Running ./gdb.base/setshow.exp ... +PASS: gdb.base/setshow.exp: default annotation_level is zero +PASS: gdb.base/setshow.exp: set annotate 2 +PASS: gdb.base/setshow.exp: show annotate 2 +PASS: gdb.base/setshow.exp: annotation_level 2 +PASS: gdb.base/setshow.exp: set annotate 1 +PASS: gdb.base/setshow.exp: show annotate (1) +PASS: gdb.base/setshow.exp: annotation_level 1 +PASS: gdb.base/setshow.exp: set annotate 0 +PASS: gdb.base/setshow.exp: show annotate (0) +PASS: gdb.base/setshow.exp: annotation_level 0 +PASS: gdb.base/setshow.exp: set args ~ +PASS: gdb.base/setshow.exp: show args ~ +PASS: gdb.base/setshow.exp: set args +PASS: gdb.base/setshow.exp: show args +PASS: gdb.base/setshow.exp: set check range on +PASS: gdb.base/setshow.exp: show check range (on) +PASS: gdb.base/setshow.exp: set check range off +PASS: gdb.base/setshow.exp: show check range (off) +PASS: gdb.base/setshow.exp: set check range auto +PASS: gdb.base/setshow.exp: show check range (auto) +PASS: gdb.base/setshow.exp: set check type on +PASS: gdb.base/setshow.exp: show check type (on) +PASS: gdb.base/setshow.exp: set check type off +PASS: gdb.base/setshow.exp: show check type (off) +PASS: gdb.base/setshow.exp: set complaints 100 +PASS: gdb.base/setshow.exp: show complaints (100) +PASS: gdb.base/setshow.exp: set complaints 0 +PASS: gdb.base/setshow.exp: show complaints (0) +PASS: gdb.base/setshow.exp: set confirm off +PASS: gdb.base/setshow.exp: show confirm (off) +PASS: gdb.base/setshow.exp: set confirm on +PASS: gdb.base/setshow.exp: show confirm (on) +PASS: gdb.base/setshow.exp: set editing off +PASS: gdb.base/setshow.exp: show editing (off) +PASS: gdb.base/setshow.exp: set environment FOOBARBAZ +PASS: gdb.base/setshow.exp: show environment FOOBARBAZ +PASS: gdb.base/setshow.exp: set height 100 +PASS: gdb.base/setshow.exp: show height +PASS: gdb.base/setshow.exp: set history expansion on +PASS: gdb.base/setshow.exp: show history expansion +PASS: gdb.base/setshow.exp: set history filename foobar.baz +PASS: gdb.base/setshow.exp: show history filename (foobar.baz) +PASS: gdb.base/setshow.exp: set history save on +PASS: gdb.base/setshow.exp: show history save (on) +PASS: gdb.base/setshow.exp: set history size 100 +PASS: gdb.base/setshow.exp: show history size (100) +PASS: gdb.base/setshow.exp: set language asm +PASS: gdb.base/setshow.exp: show language (asm) +PASS: gdb.base/setshow.exp: set language java +PASS: gdb.base/setshow.exp: show language (java) +PASS: gdb.base/setshow.exp: complete set language minimal +PASS: gdb.base/setshow.exp: set language auto +PASS: gdb.base/setshow.exp: show language (auto) +PASS: gdb.base/setshow.exp: set listsize 100 +PASS: gdb.base/setshow.exp: show listsize (100) +PASS: gdb.base/setshow.exp: set prompt FooBarBaz +PASS: gdb.base/setshow.exp: show prompt FooBarBaz +PASS: gdb.base/setshow.exp: set prompt gdb +PASS: gdb.base/setshow.exp: set radix 11 +PASS: gdb.base/setshow.exp: set radix 16 +PASS: gdb.base/setshow.exp: show radix (16) +PASS: gdb.base/setshow.exp: set radix 10 +PASS: gdb.base/setshow.exp: show radix (10) +PASS: gdb.base/setshow.exp: set width 90 +PASS: gdb.base/setshow.exp: show width (90) +PASS: gdb.base/setshow.exp: set write on +PASS: gdb.base/setshow.exp: show write (on) +PASS: gdb.base/setshow.exp: show user +PASS: gdb.base/setshow.exp: set verbose on +PASS: gdb.base/setshow.exp: show verbose (on) +PASS: gdb.base/setshow.exp: set verbose off +PASS: gdb.base/setshow.exp: show verbose (off) +Running ./gdb.base/setvar.exp ... +PASS: gdb.base/setvar.exp: set print sevenbit-strings +PASS: gdb.base/setvar.exp: set variable char=0 +PASS: gdb.base/setvar.exp: set variable char=1 +PASS: gdb.base/setvar.exp: set variable char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable char=65 ('A') +PASS: gdb.base/setvar.exp: set variable char=97 ('a') +PASS: gdb.base/setvar.exp: set variable char=126 ('~') +PASS: gdb.base/setvar.exp: set variable char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable signed char=0 +PASS: gdb.base/setvar.exp: set variable signed char=1 +PASS: gdb.base/setvar.exp: set variable signed char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable signed char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable signed char=65 ('A') +PASS: gdb.base/setvar.exp: set variable signed char=97 ('a') +PASS: gdb.base/setvar.exp: set variable signed char=126 ('~') +PASS: gdb.base/setvar.exp: set variable signed char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable v_signed_char=-1 +PASS: gdb.base/setvar.exp: set variable signed char=-1 (-1) +PASS: gdb.base/setvar.exp: set variable v_signed_char=0xFF +PASS: gdb.base/setvar.exp: set variable signed char=0xFF (0xFF) +PASS: gdb.base/setvar.exp: set variable unsigned char=0 +PASS: gdb.base/setvar.exp: set variable unsigned char=1 +PASS: gdb.base/setvar.exp: set variable unsigned char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable unsigned char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable unsigned char=65 ('A') +PASS: gdb.base/setvar.exp: set variable unsigned char=97 ('a') +PASS: gdb.base/setvar.exp: set variable unsigned char=126 ('~') +PASS: gdb.base/setvar.exp: set variable unsigned char=255 (8-bit) +PASS: gdb.base/setvar.exp: set variable short=0 +PASS: gdb.base/setvar.exp: set variable short=1 +PASS: gdb.base/setvar.exp: set variable short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed short=0 +PASS: gdb.base/setvar.exp: set variable signed short=1 +PASS: gdb.base/setvar.exp: set variable signed short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned short=0 +PASS: gdb.base/setvar.exp: set variable unsigned short=1 +PASS: gdb.base/setvar.exp: set variable unsigned short=~0 (minus) +PASS: gdb.base/setvar.exp: set variable int=0 +PASS: gdb.base/setvar.exp: set variable int=1 +PASS: gdb.base/setvar.exp: set variable int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed int=0 +PASS: gdb.base/setvar.exp: set variable signed int=1 +PASS: gdb.base/setvar.exp: set variable signed int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned int=0 +PASS: gdb.base/setvar.exp: set variable unsigned int=1 +PASS: gdb.base/setvar.exp: set variable unsigned int=~0 (minus) +PASS: gdb.base/setvar.exp: set variable long=0 +PASS: gdb.base/setvar.exp: set variable long=1 +PASS: gdb.base/setvar.exp: set variable long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed long=0 +PASS: gdb.base/setvar.exp: set variable signed long=1 +PASS: gdb.base/setvar.exp: set variable signed long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned long=0 +PASS: gdb.base/setvar.exp: set variable unsigned long=1 +PASS: gdb.base/setvar.exp: set variable unsigned long=~0 (minus) +PASS: gdb.base/setvar.exp: set variable float=0 +PASS: gdb.base/setvar.exp: set variable float=1 +PASS: gdb.base/setvar.exp: set variable float=-1 (minus) +PASS: gdb.base/setvar.exp: set variable double=0 +PASS: gdb.base/setvar.exp: set variable double=1 +PASS: gdb.base/setvar.exp: set variable double=-1 (minus) +PASS: gdb.base/setvar.exp: set variable char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable short array +PASS: gdb.base/setvar.exp: set variable signed short array +PASS: gdb.base/setvar.exp: set variable unsigned short array +PASS: gdb.base/setvar.exp: set variable int array +PASS: gdb.base/setvar.exp: set variable signed int array +PASS: gdb.base/setvar.exp: set variable unsigned int array +PASS: gdb.base/setvar.exp: set variable long array +PASS: gdb.base/setvar.exp: set variable signed long array +PASS: gdb.base/setvar.exp: set variable unsigned long array +PASS: gdb.base/setvar.exp: set variable float array +PASS: gdb.base/setvar.exp: set variable double array +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable short pointer +PASS: gdb.base/setvar.exp: set variable short pointer (#2) +PASS: gdb.base/setvar.exp: set v_signed_short_pointer=v_signed_short_array +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable signed short pointer +PASS: gdb.base/setvar.exp: print *(v_signed_short_pointer+1) +PASS: gdb.base/setvar.exp: set v_unsigned_short_pointer=v_unsigned_short_array +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable unsigned short pointer +PASS: gdb.base/setvar.exp: print *(v_unsigned_short_pointer+1) +PASS: gdb.base/setvar.exp: set variable int pointer +PASS: gdb.base/setvar.exp: set variable int pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed int pointer +PASS: gdb.base/setvar.exp: set variable signed int pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned int pointer +PASS: gdb.base/setvar.exp: print variable unsigned int pointer+1 +PASS: gdb.base/setvar.exp: set variable long pointer +PASS: gdb.base/setvar.exp: set variable long pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed long pointer +PASS: gdb.base/setvar.exp: set variable signed long pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned long pointer +PASS: gdb.base/setvar.exp: set variable unsigned long pointer (#2) +PASS: gdb.base/setvar.exp: set variable float pointer +PASS: gdb.base/setvar.exp: set variable float pointer (#2) +PASS: gdb.base/setvar.exp: set variable double pointer +PASS: gdb.base/setvar.exp: set variable double pointer (#2) +PASS: gdb.base/setvar.exp: set variable structure char member +PASS: gdb.base/setvar.exp: set variable structure short member +PASS: gdb.base/setvar.exp: set variable structure int member +PASS: gdb.base/setvar.exp: set variable structure long member +PASS: gdb.base/setvar.exp: set variable structure float member +PASS: gdb.base/setvar.exp: set variable structure double member +PASS: gdb.base/setvar.exp: set print structure #1 +PASS: gdb.base/setvar.exp: set print structure #2 +PASS: gdb.base/setvar.exp: set print structure #3 +PASS: gdb.base/setvar.exp: set print structure #4 +PASS: gdb.base/setvar.exp: print sef.field=sm1 +PASS: gdb.base/setvar.exp: print sef.field (sm1) +PASS: gdb.base/setvar.exp: print sef.field=s1 +PASS: gdb.base/setvar.exp: print sef.field (s1) +PASS: gdb.base/setvar.exp: print uef.field=u2 +PASS: gdb.base/setvar.exp: print uef.field (u2) +PASS: gdb.base/setvar.exp: print uef.field=u1 +PASS: gdb.base/setvar.exp: print uef.field (u1) +PASS: gdb.base/setvar.exp: print sef.field=7 +PASS: gdb.base/setvar.exp: print uef.field=6 +Running ./gdb.base/shell.exp ... +PASS: gdb.base/shell.exp: shell echo foo +PASS: gdb.base/shell.exp: ! echo foo +PASS: gdb.base/shell.exp: !echo foo +Running ./gdb.base/shlib-call.exp ... +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +PASS: gdb.base/shlib-call.exp: next to shr1 +PASS: gdb.base/shlib-call.exp: print g +PASS: gdb.base/shlib-call.exp: print g +PASS: gdb.base/shlib-call.exp: breakpoint function shr2 +PASS: gdb.base/shlib-call.exp: run until breakpoint set at a function +PASS: gdb.base/shlib-call.exp: print mainshr1(1) from shlib func +PASS: gdb.base/shlib-call.exp: step out of shr2 to main (stopped in shr2 epilogue) +PASS: gdb.base/shlib-call.exp: step out of shr2 epilogue to main +PASS: gdb.base/shlib-call.exp: print mainshr1(1) +PASS: gdb.base/shlib-call.exp: step into mainshr1 +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +Running ./gdb.base/shreloc.exp ... +PASS: gdb.base/shreloc.exp: get address of fn_1 +PASS: gdb.base/shreloc.exp: get address of fn_2 +PASS: gdb.base/shreloc.exp: relocated extern functions have different addresses +PASS: gdb.base/shreloc.exp: get address of extern_var_1 +PASS: gdb.base/shreloc.exp: get address of extern_var_2 +PASS: gdb.base/shreloc.exp: relocated extern variables have different addresses +PASS: gdb.base/shreloc.exp: get address of static_var_1 +PASS: gdb.base/shreloc.exp: get address of static_var_2 +PASS: gdb.base/shreloc.exp: relocated static variables have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs static_var_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated static vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs extern_var_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated extern vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs fn_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated functions have different addresses +Running ./gdb.base/sigall.exp ... +PASS: gdb.base/sigall.exp: handle SIGABRT stop print +PASS: gdb.base/sigall.exp: b handle_ABRT +PASS: gdb.base/sigall.exp: b gen_HUP +PASS: gdb.base/sigall.exp: get signal ABRT +PASS: gdb.base/sigall.exp: send signal ABRT +PASS: gdb.base/sigall.exp: advance to HUP +PASS: gdb.base/sigall.exp: handle SIGHUP stop print +PASS: gdb.base/sigall.exp: b handle_HUP +PASS: gdb.base/sigall.exp: b gen_QUIT +PASS: gdb.base/sigall.exp: get signal HUP +PASS: gdb.base/sigall.exp: send signal HUP +PASS: gdb.base/sigall.exp: advance to QUIT +PASS: gdb.base/sigall.exp: handle SIGQUIT stop print +PASS: gdb.base/sigall.exp: b handle_QUIT +PASS: gdb.base/sigall.exp: b gen_ILL +PASS: gdb.base/sigall.exp: get signal QUIT +PASS: gdb.base/sigall.exp: send signal QUIT +PASS: gdb.base/sigall.exp: advance to ILL +PASS: gdb.base/sigall.exp: handle SIGILL stop print +PASS: gdb.base/sigall.exp: b handle_ILL +PASS: gdb.base/sigall.exp: b gen_EMT +PASS: gdb.base/sigall.exp: get signal ILL +PASS: gdb.base/sigall.exp: send signal ILL +PASS: gdb.base/sigall.exp: advance to EMT +PASS: gdb.base/sigall.exp: handle SIGEMT stop print +PASS: gdb.base/sigall.exp: b handle_EMT +PASS: gdb.base/sigall.exp: b gen_FPE +PASS: gdb.base/sigall.exp: send signal EMT +PASS: gdb.base/sigall.exp: advance to FPE +PASS: gdb.base/sigall.exp: handle SIGFPE stop print +PASS: gdb.base/sigall.exp: b handle_FPE +PASS: gdb.base/sigall.exp: b gen_BUS +PASS: gdb.base/sigall.exp: get signal FPE +PASS: gdb.base/sigall.exp: send signal FPE +PASS: gdb.base/sigall.exp: advance to BUS +PASS: gdb.base/sigall.exp: handle SIGBUS stop print +PASS: gdb.base/sigall.exp: b handle_BUS +PASS: gdb.base/sigall.exp: b gen_SEGV +PASS: gdb.base/sigall.exp: get signal BUS +PASS: gdb.base/sigall.exp: send signal BUS +PASS: gdb.base/sigall.exp: advance to SEGV +PASS: gdb.base/sigall.exp: handle SIGSEGV stop print +PASS: gdb.base/sigall.exp: b handle_SEGV +PASS: gdb.base/sigall.exp: b gen_SYS +PASS: gdb.base/sigall.exp: get signal SEGV +PASS: gdb.base/sigall.exp: send signal SEGV +PASS: gdb.base/sigall.exp: advance to SYS +PASS: gdb.base/sigall.exp: handle SIGSYS stop print +PASS: gdb.base/sigall.exp: b handle_SYS +PASS: gdb.base/sigall.exp: b gen_PIPE +PASS: gdb.base/sigall.exp: get signal SYS +PASS: gdb.base/sigall.exp: send signal SYS +PASS: gdb.base/sigall.exp: advance to PIPE +PASS: gdb.base/sigall.exp: handle SIGPIPE stop print +PASS: gdb.base/sigall.exp: b handle_PIPE +PASS: gdb.base/sigall.exp: b gen_ALRM +PASS: gdb.base/sigall.exp: get signal PIPE +PASS: gdb.base/sigall.exp: send signal PIPE +PASS: gdb.base/sigall.exp: advance to ALRM +PASS: gdb.base/sigall.exp: handle SIGALRM stop print +PASS: gdb.base/sigall.exp: b handle_ALRM +PASS: gdb.base/sigall.exp: b gen_URG +PASS: gdb.base/sigall.exp: get signal ALRM +PASS: gdb.base/sigall.exp: send signal ALRM +PASS: gdb.base/sigall.exp: advance to URG +PASS: gdb.base/sigall.exp: handle SIGURG stop print +PASS: gdb.base/sigall.exp: b handle_URG +PASS: gdb.base/sigall.exp: b gen_TSTP +PASS: gdb.base/sigall.exp: get signal URG +PASS: gdb.base/sigall.exp: send signal URG +PASS: gdb.base/sigall.exp: advance to TSTP +PASS: gdb.base/sigall.exp: handle SIGTSTP stop print +PASS: gdb.base/sigall.exp: b handle_TSTP +PASS: gdb.base/sigall.exp: b gen_CONT +PASS: gdb.base/sigall.exp: get signal TSTP +PASS: gdb.base/sigall.exp: send signal TSTP +PASS: gdb.base/sigall.exp: advance to CONT +PASS: gdb.base/sigall.exp: handle SIGCONT stop print +PASS: gdb.base/sigall.exp: b handle_CONT +PASS: gdb.base/sigall.exp: b gen_CHLD +PASS: gdb.base/sigall.exp: get signal CONT +PASS: gdb.base/sigall.exp: send signal CONT +PASS: gdb.base/sigall.exp: advance to CHLD +PASS: gdb.base/sigall.exp: handle SIGCHLD stop print +PASS: gdb.base/sigall.exp: b handle_CHLD +PASS: gdb.base/sigall.exp: b gen_TTIN +PASS: gdb.base/sigall.exp: get signal CHLD +PASS: gdb.base/sigall.exp: send signal CHLD +PASS: gdb.base/sigall.exp: advance to TTIN +PASS: gdb.base/sigall.exp: handle SIGTTIN stop print +PASS: gdb.base/sigall.exp: b handle_TTIN +PASS: gdb.base/sigall.exp: b gen_TTOU +PASS: gdb.base/sigall.exp: get signal TTIN +PASS: gdb.base/sigall.exp: send signal TTIN +PASS: gdb.base/sigall.exp: advance to TTOU +PASS: gdb.base/sigall.exp: handle SIGTTOU stop print +PASS: gdb.base/sigall.exp: b handle_TTOU +PASS: gdb.base/sigall.exp: b gen_IO +PASS: gdb.base/sigall.exp: get signal TTOU +PASS: gdb.base/sigall.exp: send signal TTOU +PASS: gdb.base/sigall.exp: advance to IO +PASS: gdb.base/sigall.exp: handle SIGIO stop print +PASS: gdb.base/sigall.exp: b handle_IO +PASS: gdb.base/sigall.exp: b gen_XCPU +PASS: gdb.base/sigall.exp: get signal IO +PASS: gdb.base/sigall.exp: send signal IO +PASS: gdb.base/sigall.exp: advance to XCPU +PASS: gdb.base/sigall.exp: handle SIGXCPU stop print +PASS: gdb.base/sigall.exp: b handle_XCPU +PASS: gdb.base/sigall.exp: b gen_XFSZ +PASS: gdb.base/sigall.exp: get signal XCPU +PASS: gdb.base/sigall.exp: send signal XCPU +PASS: gdb.base/sigall.exp: advance to XFSZ +PASS: gdb.base/sigall.exp: handle SIGXFSZ stop print +PASS: gdb.base/sigall.exp: b handle_XFSZ +PASS: gdb.base/sigall.exp: b gen_VTALRM +PASS: gdb.base/sigall.exp: get signal XFSZ +PASS: gdb.base/sigall.exp: send signal XFSZ +PASS: gdb.base/sigall.exp: advance to VTALRM +PASS: gdb.base/sigall.exp: handle SIGVTALRM stop print +PASS: gdb.base/sigall.exp: b handle_VTALRM +PASS: gdb.base/sigall.exp: b gen_PROF +PASS: gdb.base/sigall.exp: get signal VTALRM +PASS: gdb.base/sigall.exp: send signal VTALRM +PASS: gdb.base/sigall.exp: advance to PROF +PASS: gdb.base/sigall.exp: handle SIGPROF stop print +PASS: gdb.base/sigall.exp: b handle_PROF +PASS: gdb.base/sigall.exp: b gen_WINCH +PASS: gdb.base/sigall.exp: get signal PROF +PASS: gdb.base/sigall.exp: send signal PROF +PASS: gdb.base/sigall.exp: advance to WINCH +PASS: gdb.base/sigall.exp: handle SIGWINCH stop print +PASS: gdb.base/sigall.exp: b handle_WINCH +PASS: gdb.base/sigall.exp: b gen_LOST +PASS: gdb.base/sigall.exp: get signal WINCH +PASS: gdb.base/sigall.exp: send signal WINCH +PASS: gdb.base/sigall.exp: advance to LOST +PASS: gdb.base/sigall.exp: handle SIGLOST stop print +PASS: gdb.base/sigall.exp: b handle_LOST +PASS: gdb.base/sigall.exp: b gen_USR1 +PASS: gdb.base/sigall.exp: send signal LOST +PASS: gdb.base/sigall.exp: advance to USR1 +PASS: gdb.base/sigall.exp: handle SIGUSR1 stop print +PASS: gdb.base/sigall.exp: b handle_USR1 +PASS: gdb.base/sigall.exp: b gen_USR2 +PASS: gdb.base/sigall.exp: get signal USR1 +PASS: gdb.base/sigall.exp: send signal USR1 +PASS: gdb.base/sigall.exp: advance to USR2 +PASS: gdb.base/sigall.exp: handle SIGUSR2 stop print +PASS: gdb.base/sigall.exp: b handle_USR2 +PASS: gdb.base/sigall.exp: b gen_PWR +PASS: gdb.base/sigall.exp: get signal USR2 +PASS: gdb.base/sigall.exp: send signal USR2 +PASS: gdb.base/sigall.exp: advance to PWR +PASS: gdb.base/sigall.exp: handle SIGPWR stop print +PASS: gdb.base/sigall.exp: b handle_PWR +PASS: gdb.base/sigall.exp: b gen_POLL +PASS: gdb.base/sigall.exp: get signal PWR +PASS: gdb.base/sigall.exp: send signal PWR +PASS: gdb.base/sigall.exp: advance to POLL +PASS: gdb.base/sigall.exp: handle SIGPOLL stop print +PASS: gdb.base/sigall.exp: b handle_POLL +PASS: gdb.base/sigall.exp: b gen_WIND +PASS: gdb.base/sigall.exp: send signal POLL +PASS: gdb.base/sigall.exp: advance to WIND +PASS: gdb.base/sigall.exp: handle SIGWIND stop print +PASS: gdb.base/sigall.exp: b handle_WIND +PASS: gdb.base/sigall.exp: b gen_PHONE +PASS: gdb.base/sigall.exp: send signal WIND +PASS: gdb.base/sigall.exp: advance to PHONE +PASS: gdb.base/sigall.exp: handle SIGPHONE stop print +PASS: gdb.base/sigall.exp: b handle_PHONE +PASS: gdb.base/sigall.exp: b gen_WAITING +PASS: gdb.base/sigall.exp: send signal PHONE +PASS: gdb.base/sigall.exp: advance to WAITING +PASS: gdb.base/sigall.exp: handle SIGWAITING stop print +PASS: gdb.base/sigall.exp: b handle_WAITING +PASS: gdb.base/sigall.exp: b gen_LWP +PASS: gdb.base/sigall.exp: send signal WAITING +PASS: gdb.base/sigall.exp: advance to LWP +PASS: gdb.base/sigall.exp: handle SIGLWP stop print +PASS: gdb.base/sigall.exp: b handle_LWP +PASS: gdb.base/sigall.exp: b gen_DANGER +PASS: gdb.base/sigall.exp: send signal LWP +PASS: gdb.base/sigall.exp: advance to DANGER +PASS: gdb.base/sigall.exp: handle SIGDANGER stop print +PASS: gdb.base/sigall.exp: b handle_DANGER +PASS: gdb.base/sigall.exp: b gen_GRANT +PASS: gdb.base/sigall.exp: send signal DANGER +PASS: gdb.base/sigall.exp: advance to GRANT +PASS: gdb.base/sigall.exp: handle SIGGRANT stop print +PASS: gdb.base/sigall.exp: b handle_GRANT +PASS: gdb.base/sigall.exp: b gen_RETRACT +PASS: gdb.base/sigall.exp: send signal GRANT +PASS: gdb.base/sigall.exp: advance to RETRACT +PASS: gdb.base/sigall.exp: handle SIGRETRACT stop print +PASS: gdb.base/sigall.exp: b handle_RETRACT +PASS: gdb.base/sigall.exp: b gen_MSG +PASS: gdb.base/sigall.exp: send signal RETRACT +PASS: gdb.base/sigall.exp: advance to MSG +PASS: gdb.base/sigall.exp: handle SIGMSG stop print +PASS: gdb.base/sigall.exp: b handle_MSG +PASS: gdb.base/sigall.exp: b gen_SOUND +PASS: gdb.base/sigall.exp: send signal MSG +PASS: gdb.base/sigall.exp: advance to SOUND +PASS: gdb.base/sigall.exp: handle SIGSOUND stop print +PASS: gdb.base/sigall.exp: b handle_SOUND +PASS: gdb.base/sigall.exp: b gen_SAK +PASS: gdb.base/sigall.exp: send signal SOUND +PASS: gdb.base/sigall.exp: advance to SAK +PASS: gdb.base/sigall.exp: handle SIGSAK stop print +PASS: gdb.base/sigall.exp: b handle_SAK +PASS: gdb.base/sigall.exp: b gen_PRIO +PASS: gdb.base/sigall.exp: send signal SAK +PASS: gdb.base/sigall.exp: advance to PRIO +PASS: gdb.base/sigall.exp: handle SIGPRIO stop print +PASS: gdb.base/sigall.exp: b handle_PRIO +PASS: gdb.base/sigall.exp: b gen_33 +PASS: gdb.base/sigall.exp: send signal PRIO +PASS: gdb.base/sigall.exp: advance to 33 +PASS: gdb.base/sigall.exp: handle SIG33 stop print +PASS: gdb.base/sigall.exp: b handle_33 +PASS: gdb.base/sigall.exp: b gen_34 +PASS: gdb.base/sigall.exp: send signal 33 +PASS: gdb.base/sigall.exp: advance to 34 +PASS: gdb.base/sigall.exp: handle SIG34 stop print +PASS: gdb.base/sigall.exp: b handle_34 +PASS: gdb.base/sigall.exp: b gen_35 +PASS: gdb.base/sigall.exp: send signal 34 +PASS: gdb.base/sigall.exp: advance to 35 +PASS: gdb.base/sigall.exp: handle SIG35 stop print +PASS: gdb.base/sigall.exp: b handle_35 +PASS: gdb.base/sigall.exp: b gen_36 +PASS: gdb.base/sigall.exp: send signal 35 +PASS: gdb.base/sigall.exp: advance to 36 +PASS: gdb.base/sigall.exp: handle SIG36 stop print +PASS: gdb.base/sigall.exp: b handle_36 +PASS: gdb.base/sigall.exp: b gen_37 +PASS: gdb.base/sigall.exp: send signal 36 +PASS: gdb.base/sigall.exp: advance to 37 +PASS: gdb.base/sigall.exp: handle SIG37 stop print +PASS: gdb.base/sigall.exp: b handle_37 +PASS: gdb.base/sigall.exp: b gen_38 +PASS: gdb.base/sigall.exp: send signal 37 +PASS: gdb.base/sigall.exp: advance to 38 +PASS: gdb.base/sigall.exp: handle SIG38 stop print +PASS: gdb.base/sigall.exp: b handle_38 +PASS: gdb.base/sigall.exp: b gen_39 +PASS: gdb.base/sigall.exp: send signal 38 +PASS: gdb.base/sigall.exp: advance to 39 +PASS: gdb.base/sigall.exp: handle SIG39 stop print +PASS: gdb.base/sigall.exp: b handle_39 +PASS: gdb.base/sigall.exp: b gen_40 +PASS: gdb.base/sigall.exp: send signal 39 +PASS: gdb.base/sigall.exp: advance to 40 +PASS: gdb.base/sigall.exp: handle SIG40 stop print +PASS: gdb.base/sigall.exp: b handle_40 +PASS: gdb.base/sigall.exp: b gen_41 +PASS: gdb.base/sigall.exp: send signal 40 +PASS: gdb.base/sigall.exp: advance to 41 +PASS: gdb.base/sigall.exp: handle SIG41 stop print +PASS: gdb.base/sigall.exp: b handle_41 +PASS: gdb.base/sigall.exp: b gen_42 +PASS: gdb.base/sigall.exp: send signal 41 +PASS: gdb.base/sigall.exp: advance to 42 +PASS: gdb.base/sigall.exp: handle SIG42 stop print +PASS: gdb.base/sigall.exp: b handle_42 +PASS: gdb.base/sigall.exp: b gen_43 +PASS: gdb.base/sigall.exp: send signal 42 +PASS: gdb.base/sigall.exp: advance to 43 +PASS: gdb.base/sigall.exp: handle SIG43 stop print +PASS: gdb.base/sigall.exp: b handle_43 +PASS: gdb.base/sigall.exp: b gen_44 +PASS: gdb.base/sigall.exp: send signal 43 +PASS: gdb.base/sigall.exp: advance to 44 +PASS: gdb.base/sigall.exp: handle SIG44 stop print +PASS: gdb.base/sigall.exp: b handle_44 +PASS: gdb.base/sigall.exp: b gen_45 +PASS: gdb.base/sigall.exp: send signal 44 +PASS: gdb.base/sigall.exp: advance to 45 +PASS: gdb.base/sigall.exp: handle SIG45 stop print +PASS: gdb.base/sigall.exp: b handle_45 +PASS: gdb.base/sigall.exp: b gen_46 +PASS: gdb.base/sigall.exp: send signal 45 +PASS: gdb.base/sigall.exp: advance to 46 +PASS: gdb.base/sigall.exp: handle SIG46 stop print +PASS: gdb.base/sigall.exp: b handle_46 +PASS: gdb.base/sigall.exp: b gen_47 +PASS: gdb.base/sigall.exp: send signal 46 +PASS: gdb.base/sigall.exp: advance to 47 +PASS: gdb.base/sigall.exp: handle SIG47 stop print +PASS: gdb.base/sigall.exp: b handle_47 +PASS: gdb.base/sigall.exp: b gen_48 +PASS: gdb.base/sigall.exp: send signal 47 +PASS: gdb.base/sigall.exp: advance to 48 +PASS: gdb.base/sigall.exp: handle SIG48 stop print +PASS: gdb.base/sigall.exp: b handle_48 +PASS: gdb.base/sigall.exp: b gen_49 +PASS: gdb.base/sigall.exp: send signal 48 +PASS: gdb.base/sigall.exp: advance to 49 +PASS: gdb.base/sigall.exp: handle SIG49 stop print +PASS: gdb.base/sigall.exp: b handle_49 +PASS: gdb.base/sigall.exp: b gen_50 +PASS: gdb.base/sigall.exp: send signal 49 +PASS: gdb.base/sigall.exp: advance to 50 +PASS: gdb.base/sigall.exp: handle SIG50 stop print +PASS: gdb.base/sigall.exp: b handle_50 +PASS: gdb.base/sigall.exp: b gen_51 +PASS: gdb.base/sigall.exp: send signal 50 +PASS: gdb.base/sigall.exp: advance to 51 +PASS: gdb.base/sigall.exp: handle SIG51 stop print +PASS: gdb.base/sigall.exp: b handle_51 +PASS: gdb.base/sigall.exp: b gen_52 +PASS: gdb.base/sigall.exp: send signal 51 +PASS: gdb.base/sigall.exp: advance to 52 +PASS: gdb.base/sigall.exp: handle SIG52 stop print +PASS: gdb.base/sigall.exp: b handle_52 +PASS: gdb.base/sigall.exp: b gen_53 +PASS: gdb.base/sigall.exp: send signal 52 +PASS: gdb.base/sigall.exp: advance to 53 +PASS: gdb.base/sigall.exp: handle SIG53 stop print +PASS: gdb.base/sigall.exp: b handle_53 +PASS: gdb.base/sigall.exp: b gen_54 +PASS: gdb.base/sigall.exp: send signal 53 +PASS: gdb.base/sigall.exp: advance to 54 +PASS: gdb.base/sigall.exp: handle SIG54 stop print +PASS: gdb.base/sigall.exp: b handle_54 +PASS: gdb.base/sigall.exp: b gen_55 +PASS: gdb.base/sigall.exp: send signal 54 +PASS: gdb.base/sigall.exp: advance to 55 +PASS: gdb.base/sigall.exp: handle SIG55 stop print +PASS: gdb.base/sigall.exp: b handle_55 +PASS: gdb.base/sigall.exp: b gen_56 +PASS: gdb.base/sigall.exp: send signal 55 +PASS: gdb.base/sigall.exp: advance to 56 +PASS: gdb.base/sigall.exp: handle SIG56 stop print +PASS: gdb.base/sigall.exp: b handle_56 +PASS: gdb.base/sigall.exp: b gen_57 +PASS: gdb.base/sigall.exp: send signal 56 +PASS: gdb.base/sigall.exp: advance to 57 +PASS: gdb.base/sigall.exp: handle SIG57 stop print +PASS: gdb.base/sigall.exp: b handle_57 +PASS: gdb.base/sigall.exp: b gen_58 +PASS: gdb.base/sigall.exp: send signal 57 +PASS: gdb.base/sigall.exp: advance to 58 +PASS: gdb.base/sigall.exp: handle SIG58 stop print +PASS: gdb.base/sigall.exp: b handle_58 +PASS: gdb.base/sigall.exp: b gen_59 +PASS: gdb.base/sigall.exp: send signal 58 +PASS: gdb.base/sigall.exp: advance to 59 +PASS: gdb.base/sigall.exp: handle SIG59 stop print +PASS: gdb.base/sigall.exp: b handle_59 +PASS: gdb.base/sigall.exp: b gen_60 +PASS: gdb.base/sigall.exp: send signal 59 +PASS: gdb.base/sigall.exp: advance to 60 +PASS: gdb.base/sigall.exp: handle SIG60 stop print +PASS: gdb.base/sigall.exp: b handle_60 +PASS: gdb.base/sigall.exp: b gen_61 +PASS: gdb.base/sigall.exp: send signal 60 +PASS: gdb.base/sigall.exp: advance to 61 +PASS: gdb.base/sigall.exp: handle SIG61 stop print +PASS: gdb.base/sigall.exp: b handle_61 +PASS: gdb.base/sigall.exp: b gen_62 +PASS: gdb.base/sigall.exp: send signal 61 +PASS: gdb.base/sigall.exp: advance to 62 +PASS: gdb.base/sigall.exp: handle SIG62 stop print +PASS: gdb.base/sigall.exp: b handle_62 +PASS: gdb.base/sigall.exp: b gen_63 +PASS: gdb.base/sigall.exp: send signal 62 +PASS: gdb.base/sigall.exp: advance to 63 +PASS: gdb.base/sigall.exp: handle SIG63 stop print +PASS: gdb.base/sigall.exp: b handle_63 +PASS: gdb.base/sigall.exp: b gen_TERM +PASS: gdb.base/sigall.exp: send signal 63 +PASS: gdb.base/sigall.exp: advance to TERM +PASS: gdb.base/sigall.exp: handle SIGTERM stop print +PASS: gdb.base/sigall.exp: b handle_TERM +PASS: gdb.base/sigall.exp: get signal TERM +PASS: gdb.base/sigall.exp: send signal TERM +PASS: gdb.base/sigall.exp: continue until exit at continue to sigall exit +Running ./gdb.base/sigaltstack.exp ... +PASS: gdb.base/sigaltstack.exp: handle SIGALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGVTALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGPROF print pass nostop +PASS: gdb.base/sigaltstack.exp: break catcher if level == INNER +PASS: gdb.base/sigaltstack.exp: continue to catch +PASS: gdb.base/sigaltstack.exp: next +PASS: gdb.base/sigaltstack.exp: backtrace +PASS: gdb.base/sigaltstack.exp: finish from catch LEAF +PASS: gdb.base/sigaltstack.exp: finish to throw INNER +PASS: gdb.base/sigaltstack.exp: finish to catch INNER +PASS: gdb.base/sigaltstack.exp: finish from catch INNER +PASS: gdb.base/sigaltstack.exp: finish to OUTER +PASS: gdb.base/sigaltstack.exp: finish to catch MAIN +PASS: gdb.base/sigaltstack.exp: finish to MAIN +Running ./gdb.base/sigbpt.exp ... +PASS: gdb.base/sigbpt.exp: break keeper +PASS: gdb.base/sigbpt.exp: display/i $pc +PASS: gdb.base/sigbpt.exp: advance to the bowler +FAIL: gdb.base/sigbpt.exp: stepping to fault +FAIL: gdb.base/sigbpt.exp: get insn after fault +FAIL: gdb.base/sigbpt.exp: Verify that SIGSEGV occurs at the last STEPI insn (none 0x55555626) +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi; nopass SIGSEGV +KFAIL: gdb.base/sigbpt.exp: stepi; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp before segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp at segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 1 of 2 +KFAIL: gdb.base/sigbpt.exp: stepi bp before and at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; continue to keeper +PASS: gdb.base/sigbpt.exp: cont; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; set breakpoint 0 of 1 +FAIL: gdb.base/sigbpt.exp: cont; continue to breakpoint at fault +FAIL: gdb.base/sigbpt.exp: cont; stepi fault +PASS: gdb.base/sigbpt.exp: cont; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 1 of 2 +FAIL: gdb.base/sigbpt.exp: cont bp after segv; continue to breakpoint at fault +FAIL: gdb.base/sigbpt.exp: cont bp after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 2 of 3 +FAIL: gdb.base/sigbpt.exp: cont bp before and after segv; continue to breakpoint at fault +FAIL: gdb.base/sigbpt.exp: cont bp before and after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 2 of 3 +Running ./gdb.base/sigchld.exp ... +PASS: gdb.base/sigchld.exp: set breakpoint at success exit +PASS: gdb.base/sigchld.exp: set breakpoint at failure exit +PASS: gdb.base/sigchld.exp: SIGCHLD blocked in inferior +Running ./gdb.base/siginfo-addr.exp ... +Running ./gdb.base/siginfo.exp ... +PASS: gdb.base/siginfo.exp: display/i $pc +PASS: gdb.base/siginfo.exp: break handler +PASS: gdb.base/siginfo.exp: continue to stepi handler +PASS: gdb.base/siginfo.exp: backtrace for nexti +PASS: gdb.base/siginfo.exp: step out of handler +Running ./gdb.base/siginfo-infcall.exp ... +PASS: gdb.base/siginfo-infcall.exp: continue to SIGUSR1 +PASS: gdb.base/siginfo-infcall.exp: p callme () +PASS: gdb.base/siginfo-infcall.exp: continue to the handler +Running ./gdb.base/siginfo-obj.exp ... +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: save a core file +PASS: gdb.base/siginfo-obj.exp: Extract si_addr +PASS: gdb.base/siginfo-obj.exp: Extract si_errno +PASS: gdb.base/siginfo-obj.exp: Extract si_code +PASS: gdb.base/siginfo-obj.exp: Extract si_signo +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr = 0x666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno = 666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_code = 999 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo = 11 +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +FAIL: gdb.base/siginfo-obj.exp: core siginfo-obj.gcore +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_code from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr from core file +Running ./gdb.base/siginfo-thread.exp ... +PASS: gdb.base/siginfo-thread.exp: successfully compiled posix threads test case +PASS: gdb.base/siginfo-thread.exp: continue to signal +PASS: gdb.base/siginfo-thread.exp: save a core file +PASS: gdb.base/siginfo-thread.exp: Extract si_addr +PASS: gdb.base/siginfo-thread.exp: Extract si_errno +PASS: gdb.base/siginfo-thread.exp: Extract si_code +PASS: gdb.base/siginfo-thread.exp: Extract si_signo +PASS: gdb.base/siginfo-thread.exp: break 39 +PASS: gdb.base/siginfo-thread.exp: continue to handler +PASS: gdb.base/siginfo-thread.exp: p ssi_addr +PASS: gdb.base/siginfo-thread.exp: p ssi_errno +PASS: gdb.base/siginfo-thread.exp: p ssi_code +PASS: gdb.base/siginfo-thread.exp: p ssi_signo +PASS: gdb.base/siginfo-thread.exp: thread 1 +PASS: gdb.base/siginfo-thread.exp: test signal in main thread +FAIL: gdb.base/siginfo-thread.exp: core siginfo-thread.gcore +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_signo from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_errno from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_code from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo._sifields._sigfault.si_addr from core file +PASS: gdb.base/siginfo-thread.exp: set variable $count = 0 +PASS: gdb.base/siginfo-thread.exp: select thread 1 with core file +FAIL: gdb.base/siginfo-thread.exp: update counter in thread 1 +PASS: gdb.base/siginfo-thread.exp: select thread 2 with core file +FAIL: gdb.base/siginfo-thread.exp: update counter in thread 2 +FAIL: gdb.base/siginfo-thread.exp: print $count +Running ./gdb.base/signals.exp ... +PASS: gdb.base/signals.exp: handle all print +PASS: gdb.base/signals.exp: set variable count = 0 +PASS: gdb.base/signals.exp: break handler if 0 +PASS: gdb.base/signals.exp: set $handler_breakpoint_number = $bpnum +PASS: gdb.base/signals.exp: next to signal +PASS: gdb.base/signals.exp: next to alarm #1 +PASS: gdb.base/signals.exp: next to ++count #1 +PASS: gdb.base/signals.exp: p func1 () #1 +PASS: gdb.base/signals.exp: p count #1 +PASS: gdb.base/signals.exp: condition $handler_breakpoint_number +PASS: gdb.base/signals.exp: next to alarm #2 +PASS: gdb.base/signals.exp: next to ++count #2 +PASS: gdb.base/signals.exp: p func1 () #2 +PASS: gdb.base/signals.exp: backtrace from handler when calling func1 +PASS: gdb.base/signals.exp: continue +PASS: gdb.base/signals.exp: p count #2 +PASS: gdb.base/signals.exp: info signals +PASS: gdb.base/signals.exp: info signal SIGTRAP +PASS: gdb.base/signals.exp: info signal 5 +PASS: gdb.base/signals.exp: handle without arguments +PASS: gdb.base/signals.exp: handle with bogus SIG +PASS: gdb.base/signals.exp: handle SIG with bogus action +PASS: gdb.base/signals.exp: handle SIG with multiple conflicting actions +PASS: gdb.base/signals.exp: handle SIG parses all legal actions +PASS: gdb.base/signals.exp: handle multiple SIGs +PASS: gdb.base/signals.exp: override SIGTRAP +PASS: gdb.base/signals.exp: invalid signal number rejected +PASS: gdb.base/signals.exp: handle multiple SIGs via integer range +PASS: gdb.base/signals.exp: handle multiple SIGs via reverse integer range +PASS: gdb.base/signals.exp: override SIGINT +PASS: gdb.base/signals.exp: signal without arguments disallowed +PASS: gdb.base/signals.exp: signal SIGUSR1 +PASS: gdb.base/signals.exp: backtrace for SIGUSR1 +Running ./gdb.base/signest.exp ... +PASS: gdb.base/signest.exp: continue to fault +PASS: gdb.base/signest.exp: set conditional breakpoint +PASS: gdb.base/signest.exp: pass SIGSEGV +PASS: gdb.base/signest.exp: pass SIGBUS +PASS: gdb.base/signest.exp: run through nested faults +Running ./gdb.base/signull.exp ... +PASS: gdb.base/signull.exp: set for function pointer probe +PASS: gdb.base/signull.exp: probe function pointer (function entry-point) +PASS: gdb.base/signull.exp: rerun to main +PASS: gdb.base/signull.exp: break bowler +PASS: gdb.base/signull.exp: break keeper +PASS: gdb.base/signull.exp: handle SIGSEGV +PASS: gdb.base/signull.exp: handle SIGBUS +PASS: gdb.base/signull.exp: data read; start with the bowler +PASS: gdb.base/signull.exp: data read; select the pointer type +PASS: gdb.base/signull.exp: data read; take the SIGSEGV +PASS: gdb.base/signull.exp: data read; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data read; continue to the keeper +PASS: gdb.base/signull.exp: data read; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: data write; start with the bowler +PASS: gdb.base/signull.exp: data write; select the pointer type +PASS: gdb.base/signull.exp: data write; take the SIGSEGV +PASS: gdb.base/signull.exp: data write; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data write; continue to the keeper +PASS: gdb.base/signull.exp: data write; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: code; start with the bowler +PASS: gdb.base/signull.exp: code; select the pointer type +PASS: gdb.base/signull.exp: code; take the SIGSEGV +PASS: gdb.base/signull.exp: code; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: code; continue to the keeper +PASS: gdb.base/signull.exp: code; backtrace from keeper through SIGSEGV +Running ./gdb.base/sigrepeat.exp ... +PASS: gdb.base/sigrepeat.exp: advance to infinite loop +PASS: gdb.base/sigrepeat.exp: next +Running ./gdb.base/sigstep.exp ... +PASS: gdb.base/sigstep.exp: display/i $pc +PASS: gdb.base/sigstep.exp: break handler +PASS: gdb.base/sigstep.exp: continue to stepi handler +PASS: gdb.base/sigstep.exp: backtrace for nexti +PASS: gdb.base/sigstep.exp: step from handler; continue to handler +PASS: gdb.base/sigstep.exp: step from handler; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; continue to handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: next from handler; continue to handler +PASS: gdb.base/sigstep.exp: next from handler; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; continue to handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: finish from handleri; continue to handler +PASS: gdb.base/sigstep.exp: finish from handleri; leave handler +PASS: gdb.base/sigstep.exp: finish from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: return from handleri; continue to handler +PASS: gdb.base/sigstep.exp: return from handleri; leave handler +PASS: gdb.base/sigstep.exp: return from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: Set done as return will have skipped it +PASS: gdb.base/sigstep.exp: set itimer = itimer_real +PASS: gdb.base/sigstep.exp: break 79 +PASS: gdb.base/sigstep.exp: step to handler; resync +PASS: gdb.base/sigstep.exp: step to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler; break handler +PASS: gdb.base/sigstep.exp: step to handler; performing step +PASS: gdb.base/sigstep.exp: step to handler; clear handler +PASS: gdb.base/sigstep.exp: next to handler; resync +PASS: gdb.base/sigstep.exp: next to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler; break handler +PASS: gdb.base/sigstep.exp: next to handler; performing next +PASS: gdb.base/sigstep.exp: next to handler; clear handler +PASS: gdb.base/sigstep.exp: continue to handler; resync +PASS: gdb.base/sigstep.exp: continue to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler; break handler +PASS: gdb.base/sigstep.exp: continue to handler; performing continue +PASS: gdb.base/sigstep.exp: continue to handler; clear handler +PASS: gdb.base/sigstep.exp: step to handler entry; resync +PASS: gdb.base/sigstep.exp: step to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler entry; break handler +PASS: gdb.base/sigstep.exp: step to handler entry; performing step +PASS: gdb.base/sigstep.exp: step to handler entry; clear handler +PASS: gdb.base/sigstep.exp: next to handler entry; resync +PASS: gdb.base/sigstep.exp: next to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler entry; break handler +PASS: gdb.base/sigstep.exp: next to handler entry; performing next +PASS: gdb.base/sigstep.exp: next to handler entry; clear handler +PASS: gdb.base/sigstep.exp: continue to handler entry; resync +PASS: gdb.base/sigstep.exp: continue to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler entry; break handler +PASS: gdb.base/sigstep.exp: continue to handler entry; performing continue +PASS: gdb.base/sigstep.exp: continue to handler entry; clear handler +PASS: gdb.base/sigstep.exp: step over handler; resync +PASS: gdb.base/sigstep.exp: step over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: step over handler; performing step +PASS: gdb.base/sigstep.exp: next over handler; resync +PASS: gdb.base/sigstep.exp: next over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: next over handler; performing next +PASS: gdb.base/sigstep.exp: continue over handler; resync +PASS: gdb.base/sigstep.exp: continue over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue over handler; performing continue +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; clear infinite loop +Running ./gdb.base/sizeof.exp ... +Running ./gdb.base/skip.exp ... +PASS: gdb.base/skip.exp: skip file (no default file) +PASS: gdb.base/skip.exp: skip function +PASS: gdb.base/skip.exp: skip (no default function) +PASS: gdb.base/skip.exp: info skip empty +PASS: gdb.base/skip.exp: skip file (skip.c) +PASS: gdb.base/skip.exp: skip (main) +PASS: gdb.base/skip.exp: skip file skip1.c +PASS: gdb.base/skip.exp: skip function baz +PASS: gdb.base/skip.exp: skip enable 999 +PASS: gdb.base/skip.exp: skip disable 999 +PASS: gdb.base/skip.exp: skip delete 999 +PASS: gdb.base/skip.exp: skip enable a +PASS: gdb.base/skip.exp: skip disable a +PASS: gdb.base/skip.exp: skip delete a +PASS: gdb.base/skip.exp: info skip 999 +PASS: gdb.base/skip.exp: info skip +PASS: gdb.base/skip.exp: step in the main +PASS: gdb.base/skip.exp: step after all ignored +PASS: gdb.base/skip.exp: skip delete 1 +PASS: gdb.base/skip.exp: info skip (delete 1) +PASS: gdb.base/skip.exp: step after deleting 1 (1) +PASS: gdb.base/skip.exp: step after deleting 1 (2) +PASS: gdb.base/skip.exp: step after deleting 1 (3) +PASS: gdb.base/skip.exp: skip disable 3 +PASS: gdb.base/skip.exp: info skip shows entry as disabled +PASS: gdb.base/skip.exp: step after disabling 3 (1) +PASS: gdb.base/skip.exp: step after disabling 3 (2) +PASS: gdb.base/skip.exp: step after disabling 3 (3) +PASS: gdb.base/skip.exp: step after disabling 3 (4) +PASS: gdb.base/skip.exp: step after disabling 3 (5) +PASS: gdb.base/skip.exp: skip enable 3 +PASS: gdb.base/skip.exp: info skip shows entry as enabled +PASS: gdb.base/skip.exp: step after enable 3 (1) +PASS: gdb.base/skip.exp: step after enable 3 (2) +PASS: gdb.base/skip.exp: step after enable 3 (3) +PASS: gdb.base/skip.exp: skip disable +PASS: gdb.base/skip.exp: info skip after disabling all +PASS: gdb.base/skip.exp: skip enable +PASS: gdb.base/skip.exp: info skip after enabling all +PASS: gdb.base/skip.exp: skip disable 4 2-3 +PASS: gdb.base/skip.exp: info skip after disabling 4 2-3 +PASS: gdb.base/skip.exp: skip enable 2-3 +PASS: gdb.base/skip.exp: info skip after enabling 2-3 +PASS: gdb.base/skip.exp: info skip 2-3 +PASS: gdb.base/skip.exp: skip delete 2 3 +PASS: gdb.base/skip.exp: info skip after deleting 2 3 +PASS: gdb.base/skip.exp: skip delete +PASS: gdb.base/skip.exp: info skip after deleting all +Running ./gdb.base/skip-solib.exp ... +Running ./gdb.base/so-impl-ld.exp ... +PASS: gdb.base/so-impl-ld.exp: step over solib call +PASS: gdb.base/so-impl-ld.exp: step into solib call +PASS: gdb.base/so-impl-ld.exp: step in solib call +PASS: gdb.base/so-impl-ld.exp: step out of solib call +Running ./gdb.base/so-indr-cl.exp ... +Running ./gdb.base/solib-corrupted.exp ... +Running ./gdb.base/solib-disc.exp ... +PASS: gdb.base/solib-disc.exp: set stop-on-solib-events 1 +PASS: gdb.base/solib-disc.exp: continue to load +PASS: gdb.base/solib-disc.exp: save $pc after load +PASS: gdb.base/solib-disc.exp: disconnect after load +PASS: gdb.base/solib-disc.exp: reconnect after load +PASS: gdb.base/solib-disc.exp: check $pc after load +PASS: gdb.base/solib-disc.exp: continue to unload +PASS: gdb.base/solib-disc.exp: save $pc after unload +PASS: gdb.base/solib-disc.exp: disconnect after unload +PASS: gdb.base/solib-disc.exp: reconnect after unload +PASS: gdb.base/solib-disc.exp: check $pc after unload +Running ./gdb.base/solib-display.exp ... +Running ./gdb.base/solib.exp ... +Running ./gdb.base/solib-nodir.exp ... +Running ./gdb.base/solib-overlap.exp ... +Running ./gdb.base/solib-symbol.exp ... +PASS: gdb.base/solib-symbol.exp: foo2 in main +PASS: gdb.base/solib-symbol.exp: foo in libmd +PASS: gdb.base/solib-symbol.exp: continue +PASS: gdb.base/solib-symbol.exp: foo2 in mdlib +Running ./gdb.base/solib-weak.exp ... +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib2 first +Running ./gdb.base/source.exp ... +PASS: gdb.base/source.exp: script contains error +PASS: gdb.base/source.exp: source -v +PASS: gdb.base/source.exp: source after -v +PASS: gdb.base/source.exp: set search directories +PASS: gdb.base/source.exp: source -s +PASS: gdb.base/source.exp: source -s -v +PASS: gdb.base/source.exp: source -v -s +Running ./gdb.base/stack-checking.exp ... +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for small frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for medium frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for big frame +PASS: gdb.base/stack-checking.exp: bt +Running ./gdb.base/stale-infcall.exp ... +PASS: gdb.base/stale-infcall.exp: continue to breakpoint: test-next +PASS: gdb.base/stale-infcall.exp: set $test_fail_bpnum=$bpnum +XFAIL: gdb.base/stale-infcall.exp: test system longjmp tracking support +UNTESTED: gdb.base/stale-infcall.exp: System lacks support for tracking longjmps +Running ./gdb.base/stap-probe.exp ... +gdb compile failed, ./gdb.base/stap-probe.c:39:21: fatal error: sys/sdt.h: No such file or directory + #include <sys/sdt.h> + ^ +compilation terminated. +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +Running ./gdb.base/start.exp ... +UNTESTED: gdb.base/start.exp: start +Running ./gdb.base/step-break.exp ... +PASS: gdb.base/step-break.exp: breakpoint line number +PASS: gdb.base/step-break.exp: run until breakpoint set at a line number +PASS: gdb.base/step-break.exp: next 2 (1) +PASS: gdb.base/step-break.exp: next 2 (2) +PASS: gdb.base/step-break.exp: next 2 (3) +PASS: gdb.base/step-break.exp: next 2 (4) +PASS: gdb.base/step-break.exp: next 2 (5) +PASS: gdb.base/step-break.exp: next 2 (6) +Running ./gdb.base/step-bt.exp ... +PASS: gdb.base/step-bt.exp: breakpoint at first instruction of hello() +PASS: gdb.base/step-bt.exp: run to hello() +PASS: gdb.base/step-bt.exp: step first instruction +PASS: gdb.base/step-bt.exp: backtrace after first instruction step +PASS: gdb.base/step-bt.exp: step second instruction +PASS: gdb.base/step-bt.exp: backtrace after second instruction step +Running ./gdb.base/step-line.exp ... +PASS: gdb.base/step-line.exp: break f1 +PASS: gdb.base/step-line.exp: continue to f1 +PASS: gdb.base/step-line.exp: next over dummy 1 +PASS: gdb.base/step-line.exp: next to dummy 2 +PASS: gdb.base/step-line.exp: next over dummy 2 +PASS: gdb.base/step-line.exp: step into f2 +PASS: gdb.base/step-line.exp: next over dummy 4 +PASS: gdb.base/step-line.exp: next to dummy 5 +PASS: gdb.base/step-line.exp: next to dummy 6 +PASS: gdb.base/step-line.exp: next over dummy 6 +PASS: gdb.base/step-line.exp: next to dummy 7 +PASS: gdb.base/step-line.exp: next to dummy 8 +PASS: gdb.base/step-line.exp: next over dummy 8 +PASS: gdb.base/step-line.exp: next to dummy 9 +PASS: gdb.base/step-line.exp: next to dummy 10 +PASS: gdb.base/step-line.exp: next over dummy 10 +Running ./gdb.base/step-resume-infcall.exp ... +PASS: gdb.base/step-resume-infcall.exp: step +PASS: gdb.base/step-resume-infcall.exp: up +PASS: gdb.base/step-resume-infcall.exp: set $b=$pc +PASS: gdb.base/step-resume-infcall.exp: print $bpnum +PASS: gdb.base/step-resume-infcall.exp: disass/m +PASS: gdb.base/step-resume-infcall.exp: info breakpoints +PASS: gdb.base/step-resume-infcall.exp: next +PASS: gdb.base/step-resume-infcall.exp: p cond_hit +Running ./gdb.base/step-symless.exp ... +PASS: gdb.base/step-symless.exp: strip stub symbols +PASS: gdb.base/step-symless.exp: step +Running ./gdb.base/step-test.exp ... +PASS: gdb.base/step-test.exp: next 1 +PASS: gdb.base/step-test.exp: step 1 +PASS: gdb.base/step-test.exp: next 2 +PASS: gdb.base/step-test.exp: step 3 +PASS: gdb.base/step-test.exp: next 3 +PASS: gdb.base/step-test.exp: next over +PASS: gdb.base/step-test.exp: step into +PASS: gdb.base/step-test.exp: step out +PASS: gdb.base/step-test.exp: stepi to next line +PASS: gdb.base/step-test.exp: stepi into function +FAIL: gdb.base/step-test.exp: stepi into function's first source line +FAIL: gdb.base/step-test.exp: stepi: finish call +FAIL: gdb.base/step-test.exp: nexti over function +PASS: gdb.base/step-test.exp: set breakpoint at call to large_struct_by_value +PASS: gdb.base/step-test.exp: run to pass large struct +PASS: gdb.base/step-test.exp: large struct by value +PASS: gdb.base/step-test.exp: continue until exit at step-test.exp +Running ./gdb.base/store.exp ... +PASS: gdb.base/store.exp: tbreak wack_charest +PASS: gdb.base/store.exp: continue to wack_charest +PASS: gdb.base/store.exp: var charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: var charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: var charest l; setting l to 4 +PASS: gdb.base/store.exp: var charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: var charest l; next over add call +PASS: gdb.base/store.exp: var charest l; print incremented l, expecting 2 ..002. +PASS: gdb.base/store.exp: tbreak wack_short +PASS: gdb.base/store.exp: continue to wack_short +PASS: gdb.base/store.exp: var short l; print old l, expecting -1 +PASS: gdb.base/store.exp: var short l; print old r, expecting -2 +PASS: gdb.base/store.exp: var short l; setting l to 4 +PASS: gdb.base/store.exp: var short l; print new l, expecting 4 +PASS: gdb.base/store.exp: var short l; next over add call +PASS: gdb.base/store.exp: var short l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_int +PASS: gdb.base/store.exp: continue to wack_int +PASS: gdb.base/store.exp: var int l; print old l, expecting -1 +PASS: gdb.base/store.exp: var int l; print old r, expecting -2 +PASS: gdb.base/store.exp: var int l; setting l to 4 +PASS: gdb.base/store.exp: var int l; print new l, expecting 4 +PASS: gdb.base/store.exp: var int l; next over add call +PASS: gdb.base/store.exp: var int l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_long +PASS: gdb.base/store.exp: continue to wack_long +PASS: gdb.base/store.exp: var long l; print old l, expecting -1 +PASS: gdb.base/store.exp: var long l; print old r, expecting -2 +PASS: gdb.base/store.exp: var long l; setting l to 4 +PASS: gdb.base/store.exp: var long l; print new l, expecting 4 +PASS: gdb.base/store.exp: var long l; next over add call +PASS: gdb.base/store.exp: var long l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_longest +PASS: gdb.base/store.exp: continue to wack_longest +PASS: gdb.base/store.exp: var longest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: var longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: var longest l; setting l to 4 +PASS: gdb.base/store.exp: var longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var longest l; next over add call +PASS: gdb.base/store.exp: var longest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_float +PASS: gdb.base/store.exp: continue to wack_float +FAIL: gdb.base/store.exp: var float l; print old l, expecting -1 +PASS: gdb.base/store.exp: var float l; print old r, expecting -2 +PASS: gdb.base/store.exp: var float l; setting l to 4 +FAIL: gdb.base/store.exp: var float l; print new l, expecting 4 +PASS: gdb.base/store.exp: var float l; next over add call +FAIL: gdb.base/store.exp: var float l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_double +PASS: gdb.base/store.exp: continue to wack_double +FAIL: gdb.base/store.exp: var double l; print old l, expecting -1 +FAIL: gdb.base/store.exp: var double l; print old r, expecting -2 +PASS: gdb.base/store.exp: var double l; setting l to 4 +FAIL: gdb.base/store.exp: var double l; print new l, expecting 4 +PASS: gdb.base/store.exp: var double l; next over add call +FAIL: gdb.base/store.exp: var double l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_doublest +PASS: gdb.base/store.exp: continue to wack_doublest +FAIL: gdb.base/store.exp: var doublest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: var doublest l; print old r, expecting -2 +FAIL: gdb.base/store.exp: var doublest l; setting l to 4 +FAIL: gdb.base/store.exp: var doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var doublest l; next over add call +FAIL: gdb.base/store.exp: var doublest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak add_charest +PASS: gdb.base/store.exp: continue to add_charest +PASS: gdb.base/store.exp: upvar charest l; up +PASS: gdb.base/store.exp: upvar charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: upvar charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: upvar charest l; set l to 4 +PASS: gdb.base/store.exp: upvar charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: tbreak add_short +PASS: gdb.base/store.exp: continue to add_short +PASS: gdb.base/store.exp: upvar short l; up +PASS: gdb.base/store.exp: upvar short l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar short l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar short l; set l to 4 +PASS: gdb.base/store.exp: upvar short l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_int +PASS: gdb.base/store.exp: continue to add_int +PASS: gdb.base/store.exp: upvar int l; up +PASS: gdb.base/store.exp: upvar int l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar int l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar int l; set l to 4 +PASS: gdb.base/store.exp: upvar int l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_long +PASS: gdb.base/store.exp: continue to add_long +PASS: gdb.base/store.exp: upvar long l; up +PASS: gdb.base/store.exp: upvar long l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar long l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar long l; set l to 4 +PASS: gdb.base/store.exp: upvar long l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_longest +PASS: gdb.base/store.exp: continue to add_longest +PASS: gdb.base/store.exp: upvar longest l; up +PASS: gdb.base/store.exp: upvar longest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: upvar longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar longest l; set l to 4 +PASS: gdb.base/store.exp: upvar longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_float +PASS: gdb.base/store.exp: continue to add_float +PASS: gdb.base/store.exp: upvar float l; up +FAIL: gdb.base/store.exp: upvar float l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar float l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar float l; set l to 4 +FAIL: gdb.base/store.exp: upvar float l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_double +PASS: gdb.base/store.exp: continue to add_double +PASS: gdb.base/store.exp: upvar double l; up +FAIL: gdb.base/store.exp: upvar double l; print old l, expecting -1 +FAIL: gdb.base/store.exp: upvar double l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar double l; set l to 4 +FAIL: gdb.base/store.exp: upvar double l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_doublest +PASS: gdb.base/store.exp: continue to add_doublest +PASS: gdb.base/store.exp: upvar doublest l; up +FAIL: gdb.base/store.exp: upvar doublest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: upvar doublest l; print old r, expecting -2 +FAIL: gdb.base/store.exp: upvar doublest l; set l to 4 +FAIL: gdb.base/store.exp: upvar doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak wack_struct_1 +PASS: gdb.base/store.exp: continue to wack_struct_1 +PASS: gdb.base/store.exp: var struct 1 u; next to add_struct_1 call +PASS: gdb.base/store.exp: var struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: var struct 1 u; set u to s_1 +PASS: gdb.base/store.exp: var struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak wack_struct_2 +PASS: gdb.base/store.exp: continue to wack_struct_2 +PASS: gdb.base/store.exp: var struct 2 u; next to add_struct_2 call +PASS: gdb.base/store.exp: var struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: var struct 2 u; set u to s_2 +PASS: gdb.base/store.exp: var struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak wack_struct_3 +PASS: gdb.base/store.exp: continue to wack_struct_3 +PASS: gdb.base/store.exp: var struct 3 u; next to add_struct_3 call +PASS: gdb.base/store.exp: var struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: var struct 3 u; set u to s_3 +PASS: gdb.base/store.exp: var struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak wack_struct_4 +PASS: gdb.base/store.exp: continue to wack_struct_4 +PASS: gdb.base/store.exp: var struct 4 u; next to add_struct_4 call +PASS: gdb.base/store.exp: var struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: var struct 4 u; set u to s_4 +PASS: gdb.base/store.exp: var struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak add_struct_1 +PASS: gdb.base/store.exp: continue to add_struct_1 +PASS: gdb.base/store.exp: up struct 1 u; up +PASS: gdb.base/store.exp: up struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: up struct 1 u; set u to s_1 +PASS: gdb.base/store.exp: up struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak add_struct_2 +PASS: gdb.base/store.exp: continue to add_struct_2 +PASS: gdb.base/store.exp: up struct 2 u; up +PASS: gdb.base/store.exp: up struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: up struct 2 u; set u to s_2 +PASS: gdb.base/store.exp: up struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak add_struct_3 +PASS: gdb.base/store.exp: continue to add_struct_3 +PASS: gdb.base/store.exp: up struct 3 u; up +PASS: gdb.base/store.exp: up struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: up struct 3 u; set u to s_3 +PASS: gdb.base/store.exp: up struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak add_struct_4 +PASS: gdb.base/store.exp: continue to add_struct_4 +PASS: gdb.base/store.exp: up struct 4 u; up +PASS: gdb.base/store.exp: up struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: up struct 4 u; set u to s_4 +PASS: gdb.base/store.exp: up struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak wack_field_1 +PASS: gdb.base/store.exp: continue field 1 +PASS: gdb.base/store.exp: next field 1 +PASS: gdb.base/store.exp: old field 1 +PASS: gdb.base/store.exp: set variable u = F_1 +PASS: gdb.base/store.exp: new field 1 +PASS: gdb.base/store.exp: set variable u = F_1, u.i = f_1.i +PASS: gdb.base/store.exp: f_1.i +PASS: gdb.base/store.exp: set variable u = F_1, u.j = f_1.j +PASS: gdb.base/store.exp: f_1.j +PASS: gdb.base/store.exp: set variable u = F_1, u.k = f_1.k +PASS: gdb.base/store.exp: f_1.k +PASS: gdb.base/store.exp: set variable u = f_1, u.i = F_1.i +PASS: gdb.base/store.exp: F_1.i +PASS: gdb.base/store.exp: set variable u = f_1, u.j = F_1.j +PASS: gdb.base/store.exp: F_1.j +PASS: gdb.base/store.exp: set variable u = f_1, u.k = F_1.k +PASS: gdb.base/store.exp: F_1.k +PASS: gdb.base/store.exp: tbreak wack_field_2 +PASS: gdb.base/store.exp: continue field 2 +PASS: gdb.base/store.exp: next field 2 +PASS: gdb.base/store.exp: old field 2 +PASS: gdb.base/store.exp: set variable u = F_2 +PASS: gdb.base/store.exp: new field 2 +PASS: gdb.base/store.exp: set variable u = F_2, u.i = f_2.i +PASS: gdb.base/store.exp: f_2.i +PASS: gdb.base/store.exp: set variable u = F_2, u.j = f_2.j +PASS: gdb.base/store.exp: f_2.j +PASS: gdb.base/store.exp: set variable u = F_2, u.k = f_2.k +PASS: gdb.base/store.exp: f_2.k +PASS: gdb.base/store.exp: set variable u = f_2, u.i = F_2.i +PASS: gdb.base/store.exp: F_2.i +PASS: gdb.base/store.exp: set variable u = f_2, u.j = F_2.j +PASS: gdb.base/store.exp: F_2.j +PASS: gdb.base/store.exp: set variable u = f_2, u.k = F_2.k +PASS: gdb.base/store.exp: F_2.k +PASS: gdb.base/store.exp: tbreak wack_field_3 +PASS: gdb.base/store.exp: continue field 3 +PASS: gdb.base/store.exp: next field 3 +PASS: gdb.base/store.exp: old field 3 +PASS: gdb.base/store.exp: set variable u = F_3 +PASS: gdb.base/store.exp: new field 3 +PASS: gdb.base/store.exp: set variable u = F_3, u.i = f_3.i +PASS: gdb.base/store.exp: f_3.i +PASS: gdb.base/store.exp: set variable u = F_3, u.j = f_3.j +PASS: gdb.base/store.exp: f_3.j +PASS: gdb.base/store.exp: set variable u = F_3, u.k = f_3.k +PASS: gdb.base/store.exp: f_3.k +PASS: gdb.base/store.exp: set variable u = f_3, u.i = F_3.i +PASS: gdb.base/store.exp: F_3.i +PASS: gdb.base/store.exp: set variable u = f_3, u.j = F_3.j +PASS: gdb.base/store.exp: F_3.j +PASS: gdb.base/store.exp: set variable u = f_3, u.k = F_3.k +PASS: gdb.base/store.exp: F_3.k +PASS: gdb.base/store.exp: tbreak wack_field_4 +PASS: gdb.base/store.exp: continue field 4 +PASS: gdb.base/store.exp: next field 4 +PASS: gdb.base/store.exp: old field 4 +PASS: gdb.base/store.exp: set variable u = F_4 +PASS: gdb.base/store.exp: new field 4 +PASS: gdb.base/store.exp: set variable u = F_4, u.i = f_4.i +PASS: gdb.base/store.exp: f_4.i +PASS: gdb.base/store.exp: set variable u = F_4, u.j = f_4.j +PASS: gdb.base/store.exp: f_4.j +PASS: gdb.base/store.exp: set variable u = F_4, u.k = f_4.k +PASS: gdb.base/store.exp: f_4.k +PASS: gdb.base/store.exp: set variable u = f_4, u.i = F_4.i +PASS: gdb.base/store.exp: F_4.i +PASS: gdb.base/store.exp: set variable u = f_4, u.j = F_4.j +PASS: gdb.base/store.exp: F_4.j +PASS: gdb.base/store.exp: set variable u = f_4, u.k = F_4.k +PASS: gdb.base/store.exp: F_4.k +Running ./gdb.base/structs2.exp ... +PASS: gdb.base/structs2.exp: set width 0 +PASS: gdb.base/structs2.exp: structs2 sanity check +PASS: gdb.base/structs2.exp: structs2 breakpoint set +PASS: gdb.base/structs2.exp: structs2 continue1 +PASS: gdb.base/structs2.exp: structs2 continue2 +Running ./gdb.base/structs3.exp ... +PASS: gdb.base/structs3.exp: print two +PASS: gdb.base/structs3.exp: print *twop +PASS: gdb.base/structs3.exp: print *(struct Two *)onep +PASS: gdb.base/structs3.exp: print *(tTwo *)onep +Running ./gdb.base/structs.exp ... +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: continue to breakpoint: chartest-done +PASS: gdb.base/structs.exp: p chartest +PASS: gdb.base/structs.exp: ptype foo1; structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 9 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 9 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 9 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 10 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 10 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 10 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 11 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 11 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 11 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 12 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 12 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 12 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 13 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 13 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 13 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 14 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 14 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 14 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 15 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 15 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 15 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 16 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 16 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 16 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 17 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 17 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 17 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 5 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 6 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 7 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 8 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 8 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 8 structs-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tll +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-td +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tld +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tld +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tld +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tll-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tld-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-td-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-td +Running ./gdb.base/subst.exp ... +PASS: gdb.base/subst.exp: deactivate GDB's confirmation interface +PASS: gdb.base/subst.exp: show substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path, too many arguments +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too few arguments +PASS: gdb.base/subst.exp: set substitute-path, first argument is empty string +PASS: gdb.base/subst.exp: add from -> to substitution rule +PASS: gdb.base/subst.exp: add from1 -> to1 substitution rule +PASS: gdb.base/subst.exp: add source -> destination substitution rule +PASS: gdb.base/subst.exp: add depuis -> vers substitution rule +PASS: gdb.base/subst.exp: add substitution rule to empty string +PASS: gdb.base/subst.exp: show substitute-path after all paths added +PASS: gdb.base/subst.exp: show substitute-path from, after all paths added +PASS: gdb.base/subst.exp: show substitute-path depuis, after all paths added +PASS: gdb.base/subst.exp: show substitute-path garbage, after all paths added +PASS: gdb.base/subst.exp: unset substitute-path from +PASS: gdb.base/subst.exp: show substitute-path from, after unsetting it +PASS: gdb.base/subst.exp: show substitute-path after from rule removed +PASS: gdb.base/subst.exp: unset substitute-path from after the rule was removed +PASS: gdb.base/subst.exp: unset substitute-path depuis (middle of list) +PASS: gdb.base/subst.exp: show substitute-path after depuis rule removed +PASS: gdb.base/subst.exp: unset substitute-path empty (end of list) +PASS: gdb.base/subst.exp: show substitute-path after empty rule removed +PASS: gdb.base/subst.exp: remove all remaining substitution rules +PASS: gdb.base/subst.exp: show substitute-path after all remaining rules removed +Running ./gdb.base/symbol-without-target_section.exp ... +PASS: gdb.base/symbol-without-target_section.exp: add-symbol-file +PASS: gdb.base/symbol-without-target_section.exp: list main +PASS: gdb.base/symbol-without-target_section.exp: print symbol_without_target_section +Running ./gdb.base/term.exp ... +Running ./gdb.base/testenv.exp ... +Running ./gdb.base/trace-commands.exp ... +PASS: gdb.base/trace-commands.exp: show trace-commands says off +PASS: gdb.base/trace-commands.exp: source -v +PASS: gdb.base/trace-commands.exp: set trace-commands +PASS: gdb.base/trace-commands.exp: show trace-commands says on +PASS: gdb.base/trace-commands.exp: simple trace-commands test +PASS: gdb.base/trace-commands.exp: nested trace-commands test +PASS: gdb.base/trace-commands.exp: define user command +PASS: gdb.base/trace-commands.exp: nested trace-commands test with source +PASS: gdb.base/trace-commands.exp: depth resets on error part 1 +PASS: gdb.base/trace-commands.exp: depth resets on error part 2 +Running ./gdb.base/tui-layout.exp ... +PASS: gdb.base/tui-layout.exp: layout asm +Running ./gdb.base/twice.exp ... +PASS: gdb.base/twice.exp: step +Running ./gdb.base/type-opaque.exp ... +PASS: gdb.base/type-opaque.exp: opaque struct type resolving +PASS: gdb.base/type-opaque.exp: empty struct type resolving +PASS: gdb.base/type-opaque.exp: filled struct type resolving +PASS: gdb.base/type-opaque.exp: opaque union type resolving +PASS: gdb.base/type-opaque.exp: empty union type resolving +PASS: gdb.base/type-opaque.exp: filled union type resolving +Running ./gdb.base/ui-redirect.exp ... +PASS: gdb.base/ui-redirect.exp: commands +PASS: gdb.base/ui-redirect.exp: print 1 +PASS: gdb.base/ui-redirect.exp: end +PASS: gdb.base/ui-redirect.exp: set logging file /dev/null +PASS: gdb.base/ui-redirect.exp: set logging on +PASS: gdb.base/ui-redirect.exp: save breakpoints /dev/null +PASS: gdb.base/ui-redirect.exp: set logging off +PASS: gdb.base/ui-redirect.exp: help +Running ./gdb.base/unload.exp ... +PASS: gdb.base/unload.exp: pending breakpoint info before run +PASS: gdb.base/unload.exp: running program +PASS: gdb.base/unload.exp: pending breakpoint info on first run at shrfunc1 +PASS: gdb.base/unload.exp: continuing to unloaded libfile +PASS: gdb.base/unload.exp: print y from libfile +PASS: gdb.base/unload.exp: rerun to shared library breakpoint +PASS: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc1 +PASS: gdb.base/unload.exp: continuing to unloaded libfile +PASS: gdb.base/unload.exp: continue to shrfunc2 +PASS: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc2 +PASS: gdb.base/unload.exp: continuing to unloaded libfile2 +PASS: gdb.base/unload.exp: print y from libfile2 +Running ./gdb.base/until.exp ... +PASS: gdb.base/until.exp: until line number +PASS: gdb.base/until.exp: malformed until +PASS: gdb.base/until.exp: until factorial, recursive function +PASS: gdb.base/until.exp: until func, not called by current frame +Running ./gdb.base/unwindonsignal.exp ... +Running ./gdb.base/valgrind-db-attach.exp ... +Running ./gdb.base/valgrind-infcall.exp ... +Running ./gdb.base/value-double-free.exp ... +PASS: gdb.base/value-double-free.exp: watch var +PASS: gdb.base/value-double-free.exp: continue +PASS: gdb.base/value-double-free.exp: print empty() +PASS: gdb.base/value-double-free.exp: help help +Running ./gdb.base/varargs.exp ... +PASS: gdb.base/varargs.exp: set print sevenbit-strings +PASS: gdb.base/varargs.exp: set print address off +PASS: gdb.base/varargs.exp: set width 0 +Running ./gdb.base/volatile.exp ... +PASS: gdb.base/volatile.exp: continue to marker1 +PASS: gdb.base/volatile.exp: up from marker1 +PASS: gdb.base/volatile.exp: ptype vox +PASS: gdb.base/volatile.exp: ptype victuals +PASS: gdb.base/volatile.exp: ptype vixen +PASS: gdb.base/volatile.exp: ptype vitriol +PASS: gdb.base/volatile.exp: ptype vellum +PASS: gdb.base/volatile.exp: ptype valve +PASS: gdb.base/volatile.exp: ptype vacuity +PASS: gdb.base/volatile.exp: ptype vertigo +PASS: gdb.base/volatile.exp: ptype vampire +PASS: gdb.base/volatile.exp: ptype viper +PASS: gdb.base/volatile.exp: ptype vigour +PASS: gdb.base/volatile.exp: ptype vapour +PASS: gdb.base/volatile.exp: ptype ventricle +PASS: gdb.base/volatile.exp: ptype vigintillion +PASS: gdb.base/volatile.exp: ptype vocation +PASS: gdb.base/volatile.exp: ptype veracity +PASS: gdb.base/volatile.exp: ptype vapidity +PASS: gdb.base/volatile.exp: ptype velocity +PASS: gdb.base/volatile.exp: ptype veneer +PASS: gdb.base/volatile.exp: ptype video +PASS: gdb.base/volatile.exp: ptype vacuum +PASS: gdb.base/volatile.exp: ptype veniality +PASS: gdb.base/volatile.exp: ptype vitality +PASS: gdb.base/volatile.exp: ptype voracity +PASS: gdb.base/volatile.exp: ptype victor +PASS: gdb.base/volatile.exp: ptype vicar +PASS: gdb.base/volatile.exp: ptype victory +PASS: gdb.base/volatile.exp: ptype vicarage +PASS: gdb.base/volatile.exp: ptype vein +PASS: gdb.base/volatile.exp: ptype vogue +PASS: gdb.base/volatile.exp: ptype cavern +PASS: gdb.base/volatile.exp: ptype coverlet +PASS: gdb.base/volatile.exp: ptype caveat +PASS: gdb.base/volatile.exp: ptype covenant +PASS: gdb.base/volatile.exp: ptype vizier +PASS: gdb.base/volatile.exp: ptype vanadium +PASS: gdb.base/volatile.exp: ptype vane +PASS: gdb.base/volatile.exp: ptype veldt +PASS: gdb.base/volatile.exp: ptype cove +PASS: gdb.base/volatile.exp: ptype cavity +PASS: gdb.base/volatile.exp: ptype vagus +PASS: gdb.base/volatile.exp: ptype vagrancy +PASS: gdb.base/volatile.exp: ptype vagary +PASS: gdb.base/volatile.exp: ptype vendor +PASS: gdb.base/volatile.exp: ptype qux2 +Running ./gdb.base/watch-cond.exp ... +PASS: gdb.base/watch-cond.exp: set write watchpoint on global variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with global expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on local variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with local expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on global2 variable +PASS: gdb.base/watch-cond.exp: watchpoint on global2 variable triggers +PASS: gdb.base/watch-cond.exp: condition of watchpoint 2 changes +PASS: gdb.base/watch-cond.exp: watchpoint stops with untestable local expression +Running ./gdb.base/watch-cond-infcall.exp ... +PASS: gdb.base/watch-cond-infcall.exp: sw: watch var if return_1 () +PASS: gdb.base/watch-cond-infcall.exp: sw: continue +Running ./gdb.base/watch-non-mem.exp ... +PASS: gdb.base/watch-non-mem.exp: set write watchpoint on $pc +PASS: gdb.base/watch-non-mem.exp: watchpoint on $pc works +Running ./gdb.base/watchpoint-cond-gone.exp ... +PASS: gdb.base/watchpoint-cond-gone.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-cond-gone.exp: continue to breakpoint: Place to set the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Place the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Catch the no longer valid watchpoint +Running ./gdb.base/watchpoint-delete.exp ... +PASS: gdb.base/watchpoint-delete.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-delete.exp: continue to breakpoint: break-here +PASS: gdb.base/watchpoint-delete.exp: watch x +PASS: gdb.base/watchpoint-delete.exp: delete $bpnum +Running ./gdb.base/watchpoint.exp ... +PASS: gdb.base/watchpoint.exp: disable fast watches +PASS: gdb.base/watchpoint.exp: show disable fast watches +PASS: gdb.base/watchpoint.exp: set slow conditional watch +PASS: gdb.base/watchpoint.exp: trigger slow conditional watch +PASS: gdb.base/watchpoint.exp: delete watch ival3 +PASS: gdb.base/watchpoint.exp: set slow condition watch w/thread +PASS: gdb.base/watchpoint.exp: delete watch w/condition and thread +PASS: gdb.base/watchpoint.exp: rwatch disallowed when can-set-hw-watchpoints cleared +PASS: gdb.base/watchpoint.exp: set breakpoint at marker1 +PASS: gdb.base/watchpoint.exp: set breakpoint at marker2 +PASS: gdb.base/watchpoint.exp: info break in watchpoint.exp +PASS: gdb.base/watchpoint.exp: set watchpoint on ival3 +PASS: gdb.base/watchpoint.exp: watchpoint found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: run to marker1 in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: enable watchpoint +PASS: gdb.base/watchpoint.exp: break func1 +PASS: gdb.base/watchpoint.exp: set $func1_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: continue to breakpoint at func1 +PASS: gdb.base/watchpoint.exp: watchpoint hit, first time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoint.exp: delete $func1_breakpoint_number +PASS: gdb.base/watchpoint.exp: watchpoint hit, second time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoint.exp: watchpoint hit, third time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 5 +PASS: gdb.base/watchpoint.exp: continue to marker2 +PASS: gdb.base/watchpoint.exp: watchpoint disabled +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: watchpoints found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: run to marker1 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint enabled +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, first time +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, second time +PASS: gdb.base/watchpoint.exp: disable watchpoint #2 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint disabled in table +PASS: gdb.base/watchpoint.exp: disabled watchpoint skipped +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watch ival2 +PASS: gdb.base/watchpoint.exp: break func2 if 0 +PASS: gdb.base/watchpoint.exp: p $func2_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: calling function with watchpoint enabled +PASS: gdb.base/watchpoint.exp: finish from marker1 +PASS: gdb.base/watchpoint.exp: back at main from marker1 +PASS: gdb.base/watchpoint.exp: next to `for' in watchpoint.exp +PASS: gdb.base/watchpoint.exp: until to ival1 assignment +PASS: gdb.base/watchpoint.exp: until to ival3 assignment +PASS: gdb.base/watchpoint.exp: until out of loop +PASS: gdb.base/watchpoint.exp: step to ival2 assignment +PASS: gdb.base/watchpoint.exp: watch ptr1->val +PASS: gdb.base/watchpoint.exp: break marker5 +PASS: gdb.base/watchpoint.exp: Test complex watchpoint +PASS: gdb.base/watchpoint.exp: did not trigger wrong watchpoint +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: break marker6 +PASS: gdb.base/watchpoint.exp: continue to marker6 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set local watch +PASS: gdb.base/watchpoint.exp: trigger local watch +PASS: gdb.base/watchpoint.exp: self-delete local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set partially local watch +PASS: gdb.base/watchpoint.exp: trigger1 partially local watch +PASS: gdb.base/watchpoint.exp: trigger2 partially local watch +PASS: gdb.base/watchpoint.exp: self-delete partially local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set static local watch +PASS: gdb.base/watchpoint.exp: trigger static local watch +PASS: gdb.base/watchpoint.exp: continue after trigger static local watch +PASS: gdb.base/watchpoint.exp: static local watch did not self-delete +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call +PASS: gdb.base/watchpoint.exp: trigger local watch in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch in recursive call +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call with explicit scope +PASS: gdb.base/watchpoint.exp: trigger local watch with explicit scope in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch with explicit scope in recursive call (2) +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: watchpoint refused to insert on nonexistent struct member +PASS: gdb.base/watchpoint.exp: watch global_ptr +PASS: gdb.base/watchpoint.exp: watch *(int *) 0 +PASS: gdb.base/watchpoint.exp: watch -location *global_ptr +PASS: gdb.base/watchpoint.exp: watch *global_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: global_ptr next +PASS: gdb.base/watchpoint.exp: next over ptr init +PASS: gdb.base/watchpoint.exp: next over buffer set +PASS: gdb.base/watchpoint.exp: delete $global_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: watch **global_ptr_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_ptr_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: global_ptr_ptr next +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr init +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr buffer set +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr pointer advance +PASS: gdb.base/watchpoint.exp: delete $global_ptr_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: continue to breakpoint: second x assignment +PASS: gdb.base/watchpoint.exp: watch x +PASS: gdb.base/watchpoint.exp: next after watch x +PASS: gdb.base/watchpoint.exp: delete watch x +PASS: gdb.base/watchpoint.exp: watch buf +PASS: gdb.base/watchpoint.exp: watchpoint on buf hit +PASS: gdb.base/watchpoint.exp: delete watch buf +PASS: gdb.base/watchpoint.exp: number is constant +PASS: gdb.base/watchpoint.exp: number with cast is constant +PASS: gdb.base/watchpoint.exp: marker1 is constant +PASS: gdb.base/watchpoint.exp: watch count + 6 +PASS: gdb.base/watchpoint.exp: delete watchpoint `count + 6' +PASS: gdb.base/watchpoint.exp: watch 7 + count +PASS: gdb.base/watchpoint.exp: delete watchpoint `7 + count' +PASS: gdb.base/watchpoint.exp: watch $pc +PASS: gdb.base/watchpoint.exp: disable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: reenable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: watchpoint `$pc' is enabled +PASS: gdb.base/watchpoint.exp: delete watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func5 breakpoint here +PASS: gdb.base/watchpoint.exp: watch -location .x +PASS: gdb.base/watchpoint.exp: continue with watch -location +PASS: gdb.base/watchpoint.exp: delete watch -location +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func6 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo2 +PASS: gdb.base/watchpoint.exp: continue with watch foo2 +PASS: gdb.base/watchpoint.exp: delete watch foo2 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func7 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo4 +PASS: gdb.base/watchpoint.exp: continue with watch foo4 +PASS: gdb.base/watchpoint.exp: delete watch foo4 +Running ./gdb.base/watchpoint-hw.exp ... +Running ./gdb.base/watchpoint-hw-hit-once.exp ... +Running ./gdb.base/watchpoints.exp ... +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 5 +Running ./gdb.base/watchpoint-solib.exp ... +PASS: gdb.base/watchpoint-solib.exp: set pending breakpoint +PASS: gdb.base/watchpoint-solib.exp: continue to foo +PASS: gdb.base/watchpoint-solib.exp: set watchpoint on g +PASS: gdb.base/watchpoint-solib.exp: continue to watchpoint hit +PASS: gdb.base/watchpoint-solib.exp: rerun to main +PASS: gdb.base/watchpoint-solib.exp: continue to foo again +PASS: gdb.base/watchpoint-solib.exp: continue to watchpoint hit again +Running ./gdb.base/watch-read.exp ... +Running ./gdb.base/watch_thread_num.exp ... +Running ./gdb.base/watch-vfork.exp ... +Running ./gdb.base/wchar.exp ... +PASS: gdb.base/wchar.exp: print narrow +PASS: gdb.base/wchar.exp: print single +PASS: gdb.base/wchar.exp: print simple +PASS: gdb.base/wchar.exp: print difficile +PASS: gdb.base/wchar.exp: print simple[2] +PASS: gdb.base/wchar.exp: print difficile[2] +PASS: gdb.base/wchar.exp: print repeat +PASS: gdb.base/wchar.exp: print repeat_p +PASS: gdb.base/wchar.exp: set print null on +PASS: gdb.base/wchar.exp: print repeat (print null on) +PASS: gdb.base/wchar.exp: set print elements 3 +PASS: gdb.base/wchar.exp: print repeat (print elements 3) +PASS: gdb.base/wchar.exp: print repeat_p (print elements 3) +Running ./gdb.base/whatis.exp ... +PASS: gdb.base/whatis.exp: whatis char +PASS: gdb.base/whatis.exp: whatis signed char +PASS: gdb.base/whatis.exp: whatis unsigned char +PASS: gdb.base/whatis.exp: whatis short +PASS: gdb.base/whatis.exp: whatis signed short +PASS: gdb.base/whatis.exp: whatis unsigned short +PASS: gdb.base/whatis.exp: whatis int +PASS: gdb.base/whatis.exp: whatis signed int +PASS: gdb.base/whatis.exp: whatis unsigned int +PASS: gdb.base/whatis.exp: whatis long +PASS: gdb.base/whatis.exp: whatis signed long +PASS: gdb.base/whatis.exp: whatis unsigned long +PASS: gdb.base/whatis.exp: whatis unsigned long long +PASS: gdb.base/whatis.exp: whatis float +PASS: gdb.base/whatis.exp: whatis double +PASS: gdb.base/whatis.exp: whatis char array +PASS: gdb.base/whatis.exp: whatis signed char array +PASS: gdb.base/whatis.exp: whatis unsigned char array +PASS: gdb.base/whatis.exp: whatis short array +PASS: gdb.base/whatis.exp: whatis signed short array +PASS: gdb.base/whatis.exp: whatis unsigned short array +PASS: gdb.base/whatis.exp: whatis int array +PASS: gdb.base/whatis.exp: whatis signed int array +PASS: gdb.base/whatis.exp: whatis unsigned int array +PASS: gdb.base/whatis.exp: whatis long array +PASS: gdb.base/whatis.exp: whatis signed long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis float array +PASS: gdb.base/whatis.exp: whatis double array +PASS: gdb.base/whatis.exp: whatis char pointer +PASS: gdb.base/whatis.exp: whatis signed char pointer +PASS: gdb.base/whatis.exp: whatis unsigned char pointer +PASS: gdb.base/whatis.exp: whatis short pointer +PASS: gdb.base/whatis.exp: whatis signed short pointer +PASS: gdb.base/whatis.exp: whatis unsigned short pointer +PASS: gdb.base/whatis.exp: whatis int pointer +PASS: gdb.base/whatis.exp: whatis signed int pointer +PASS: gdb.base/whatis.exp: whatis unsigned int pointer +PASS: gdb.base/whatis.exp: whatis long pointer +PASS: gdb.base/whatis.exp: whatis signed long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long pointer +PASS: gdb.base/whatis.exp: whatis long long pointer +PASS: gdb.base/whatis.exp: whatis signed long long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long long pointer +PASS: gdb.base/whatis.exp: whatis float pointer +PASS: gdb.base/whatis.exp: whatis double pointer +PASS: gdb.base/whatis.exp: whatis named structure +PASS: gdb.base/whatis.exp: whatis named structure using type name +PASS: gdb.base/whatis.exp: whatis unnamed structure +PASS: gdb.base/whatis.exp: whatis named union +PASS: gdb.base/whatis.exp: whatis named union using type name +PASS: gdb.base/whatis.exp: whatis unnamed union +PASS: gdb.base/whatis.exp: whatis char function +PASS: gdb.base/whatis.exp: whatis signed char function +PASS: gdb.base/whatis.exp: whatis unsigned char function +PASS: gdb.base/whatis.exp: whatis short function +PASS: gdb.base/whatis.exp: whatis signed short function +PASS: gdb.base/whatis.exp: whatis unsigned short function +PASS: gdb.base/whatis.exp: whatis int function +PASS: gdb.base/whatis.exp: whatis signed int function +PASS: gdb.base/whatis.exp: whatis unsigned int function +PASS: gdb.base/whatis.exp: whatis long function +PASS: gdb.base/whatis.exp: whatis signed long function +PASS: gdb.base/whatis.exp: whatis unsigned long function +PASS: gdb.base/whatis.exp: whatis long long function +PASS: gdb.base/whatis.exp: whatis signed long long function +PASS: gdb.base/whatis.exp: whatis unsigned long long function +PASS: gdb.base/whatis.exp: whatis float function +PASS: gdb.base/whatis.exp: whatis double function +PASS: gdb.base/whatis.exp: whatis complicated structure +PASS: gdb.base/whatis.exp: whatis complicated union +PASS: gdb.base/whatis.exp: whatis enumeration +PASS: gdb.base/whatis.exp: whatis enumeration using type name +PASS: gdb.base/whatis.exp: whatis outer structure +PASS: gdb.base/whatis.exp: whatis outer structure member +PASS: gdb.base/whatis.exp: whatis inner structure +PASS: gdb.base/whatis.exp: whatis inner structure member +PASS: gdb.base/whatis.exp: whatis inner union +PASS: gdb.base/whatis.exp: whatis inner union member +PASS: gdb.base/whatis.exp: whatis using typedef type name +PASS: gdb.base/whatis.exp: whatis applied to variable defined by typedef +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to const pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to const pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to array +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking int,int and returning int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking const int ptr and varargs and returning int +PASS: gdb.base/whatis.exp: whatis applied to function with types trailing 'void' +PASS: gdb.base/whatis.exp: whatis applied to function with 'void' parameter type +Running ./gdb.base/whatis-exp.exp ... +PASS: gdb.base/whatis-exp.exp: set variable x=14 +PASS: gdb.base/whatis-exp.exp: set variable y=2 +PASS: gdb.base/whatis-exp.exp: set variable z=2 +PASS: gdb.base/whatis-exp.exp: set variable w=3 +PASS: gdb.base/whatis-exp.exp: print value of x +PASS: gdb.base/whatis-exp.exp: print value of y +PASS: gdb.base/whatis-exp.exp: print value of z +PASS: gdb.base/whatis-exp.exp: print value of w +PASS: gdb.base/whatis-exp.exp: whatis value of x+y +PASS: gdb.base/whatis-exp.exp: whatis value of x-y +PASS: gdb.base/whatis-exp.exp: whatis value of x*y +PASS: gdb.base/whatis-exp.exp: whatis value of x/y +PASS: gdb.base/whatis-exp.exp: whatis value of x%y +PASS: gdb.base/whatis-exp.exp: whatis value of x=y +PASS: gdb.base/whatis-exp.exp: whatis value of x+=2 +PASS: gdb.base/whatis-exp.exp: whatis value of ++x +PASS: gdb.base/whatis-exp.exp: whatis value of --x +PASS: gdb.base/whatis-exp.exp: whatis value of x++ +PASS: gdb.base/whatis-exp.exp: whatis value of x-- +Running ./gdb.btrace/enable.exp ... +Running ./gdb.btrace/function_call_history.exp ... +Running ./gdb.btrace/instruction_history.exp ... +Running ./gdb.cell/arch.exp ... +Running ./gdb.cell/break.exp ... +Running ./gdb.cell/bt.exp ... +Running ./gdb.cell/core.exp ... +Running ./gdb.cell/data.exp ... +Running ./gdb.cell/dwarfaddr.exp ... +Running ./gdb.cell/ea-cache.exp ... +Running ./gdb.cell/ea-standalone.exp ... +Running ./gdb.cell/ea-test.exp ... +Running ./gdb.cell/fork.exp ... +Running ./gdb.cell/f-regs.exp ... +Running ./gdb.cell/gcore.exp ... +Running ./gdb.cell/mem-access.exp ... +Running ./gdb.cell/ptype.exp ... +Running ./gdb.cell/registers.exp ... +Running ./gdb.cell/sizeof.exp ... +Running ./gdb.cell/solib.exp ... +Running ./gdb.cell/solib-symbol.exp ... +Running ./gdb.cp/abstract-origin.exp ... +PASS: gdb.cp/abstract-origin.exp: continue to breakpoint: break-here +PASS: gdb.cp/abstract-origin.exp: p problem +Running ./gdb.cp/ambiguous.exp ... +Running ./gdb.cp/annota2.exp ... +Running ./gdb.cp/annota3.exp ... +Running ./gdb.cp/anon-ns.exp ... +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +Running ./gdb.cp/anon-struct.exp ... +FAIL: gdb.cp/anon-struct.exp: print type of t::t +PASS: gdb.cp/anon-struct.exp: print type of X::t2 +FAIL: gdb.cp/anon-struct.exp: print type of X::t2::t2 +FAIL: gdb.cp/anon-struct.exp: print type of t3::~t3 +Running ./gdb.cp/anon-union.exp ... +PASS: gdb.cp/anon-union.exp: set width 0 +PASS: gdb.cp/anon-union.exp: next 1 +PASS: gdb.cp/anon-union.exp: print foo 1 +PASS: gdb.cp/anon-union.exp: next 2 +PASS: gdb.cp/anon-union.exp: print foo 2 +PASS: gdb.cp/anon-union.exp: set var foo.cloth +PASS: gdb.cp/anon-union.exp: print foo 3 +PASS: gdb.cp/anon-union.exp: next 3 +PASS: gdb.cp/anon-union.exp: print foo 4 +PASS: gdb.cp/anon-union.exp: set var foo.pebble +PASS: gdb.cp/anon-union.exp: print foo 5 +PASS: gdb.cp/anon-union.exp: set var foo.qux +PASS: gdb.cp/anon-union.exp: print foo 6 +PASS: gdb.cp/anon-union.exp: set var foo.mux +PASS: gdb.cp/anon-union.exp: print foo 7 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock +PASS: gdb.cp/anon-union.exp: print foo 8 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock2 +PASS: gdb.cp/anon-union.exp: print foo 9 +PASS: gdb.cp/anon-union.exp: next 4 +PASS: gdb.cp/anon-union.exp: print w 1 +PASS: gdb.cp/anon-union.exp: print z 1 +PASS: gdb.cp/anon-union.exp: next 5 +PASS: gdb.cp/anon-union.exp: print w 2 +PASS: gdb.cp/anon-union.exp: print z 2 +PASS: gdb.cp/anon-union.exp: set var z +PASS: gdb.cp/anon-union.exp: print w 3 +PASS: gdb.cp/anon-union.exp: print z 3 +Running ./gdb.cp/arg-reference.exp ... +PASS: gdb.cp/arg-reference.exp: No false reference +Running ./gdb.cp/baseenum.exp ... +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 1 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 2 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A in namespace N +Running ./gdb.cp/bool.exp ... +PASS: gdb.cp/bool.exp: print return_true() +PASS: gdb.cp/bool.exp: print return_false() +Running ./gdb.cp/breakpoint.exp ... +PASS: gdb.cp/breakpoint.exp: continue to C1::Nested::foo +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method 2 +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +Running ./gdb.cp/bs15503.exp ... +PASS: gdb.cp/bs15503.exp: break StringTest<wchar_t>::testFunction +PASS: gdb.cp/bs15503.exp: continue to StringTest<wchar_t> +PASS: gdb.cp/bs15503.exp: continue to breakpoint: find position where blank needs to be inserted +FAIL: gdb.cp/bs15503.exp: print s.length() +FAIL: gdb.cp/bs15503.exp: print s[0] +FAIL: gdb.cp/bs15503.exp: print s[s.length()-1] +PASS: gdb.cp/bs15503.exp: print (const char *) s +FAIL: gdb.cp/bs15503.exp: print (const char *) s.substr(0,4) +FAIL: gdb.cp/bs15503.exp: print (const char *) (s=s.substr(0,4)) +Running ./gdb.cp/call-c.exp ... +PASS: gdb.cp/call-c.exp: b 43 +PASS: gdb.cp/call-c.exp: print foo(1) +PASS: gdb.cp/call-c.exp: continue to bp +PASS: gdb.cp/call-c.exp: print rf->func() +PASS: gdb.cp/call-c.exp: print handle->func() +Running ./gdb.cp/casts.exp ... +PASS: gdb.cp/casts.exp: cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: let compiler cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: cast derived class pointer to base class pointer +PASS: gdb.cp/casts.exp: cast derived class reference to base class reference +PASS: gdb.cp/casts.exp: cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: let compiler cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: basic test of const_cast +PASS: gdb.cp/casts.exp: const_cast of 0 +PASS: gdb.cp/casts.exp: basic test of static_cast +PASS: gdb.cp/casts.exp: static_cast to reference type +PASS: gdb.cp/casts.exp: basic test of reinterpret_cast +PASS: gdb.cp/casts.exp: test invalid reinterpret_cast +PASS: gdb.cp/casts.exp: reinterpret_cast to reference type +PASS: gdb.cp/casts.exp: whatis decltype(5) +PASS: gdb.cp/casts.exp: old-style cast using __typeof__ +PASS: gdb.cp/casts.exp: static_cast using __typeof__ +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof__ +PASS: gdb.cp/casts.exp: old-style cast using __typeof +PASS: gdb.cp/casts.exp: static_cast using __typeof +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof +PASS: gdb.cp/casts.exp: old-style cast using __decltype +PASS: gdb.cp/casts.exp: static_cast using __decltype +PASS: gdb.cp/casts.exp: reinterpret_cast using __decltype +PASS: gdb.cp/casts.exp: whatis __decltype(*a) +PASS: gdb.cp/casts.exp: invalid dynamic_cast +PASS: gdb.cp/casts.exp: dynamic_cast of 0 to void* +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast +PASS: gdb.cp/casts.exp: dynamic_cast upcast to unique base +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast to reference +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast to intermediate class +PASS: gdb.cp/casts.exp: dynamic_cast to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast to reference to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast unique downcast +PASS: gdb.cp/casts.exp: dynamic_cast to sibling +Running ./gdb.cp/class2.exp ... +PASS: gdb.cp/class2.exp: set print object off +PASS: gdb.cp/class2.exp: print alpha at marker return 0 +PASS: gdb.cp/class2.exp: print beta at marker return 0 +PASS: gdb.cp/class2.exp: print * aap at marker return 0 +PASS: gdb.cp/class2.exp: print * bbp at marker return 0 +PASS: gdb.cp/class2.exp: print * abp at marker return 0, s-p-o off +PASS: gdb.cp/class2.exp: print * (B *) abp at marker return 0 +PASS: gdb.cp/class2.exp: print object with no data fields +PASS: gdb.cp/class2.exp: set print object on +PASS: gdb.cp/class2.exp: p acp +PASS: gdb.cp/class2.exp: p acp->c1 +PASS: gdb.cp/class2.exp: p acp->c2 +Running ./gdb.cp/classes.exp ... +PASS: gdb.cp/classes.exp: ptype struct default_public_struct +PASS: gdb.cp/classes.exp: ptype struct explicit_public_struct +PASS: gdb.cp/classes.exp: ptype struct protected_struct +PASS: gdb.cp/classes.exp: ptype struct private_struct +PASS: gdb.cp/classes.exp: ptype struct mixed_protection_struct +PASS: gdb.cp/classes.exp: ptype class public_class +PASS: gdb.cp/classes.exp: ptype class protected_class +PASS: gdb.cp/classes.exp: ptype class default_private_class +PASS: gdb.cp/classes.exp: ptype class explicit_private_class +PASS: gdb.cp/classes.exp: ptype class mixed_protection_class +PASS: gdb.cp/classes.exp: ptype class A +PASS: gdb.cp/classes.exp: ptype class B +PASS: gdb.cp/classes.exp: ptype class C +PASS: gdb.cp/classes.exp: ptype class D +PASS: gdb.cp/classes.exp: ptype class E +PASS: gdb.cp/classes.exp: ptype class Static +PASS: gdb.cp/classes.exp: ptype class vA +PASS: gdb.cp/classes.exp: ptype class vB +PASS: gdb.cp/classes.exp: ptype class vC +PASS: gdb.cp/classes.exp: ptype class vD +PASS: gdb.cp/classes.exp: ptype class vE +PASS: gdb.cp/classes.exp: ptype class Base1 +PASS: gdb.cp/classes.exp: ptype class Foo +PASS: gdb.cp/classes.exp: ptype class Bar +PASS: gdb.cp/classes.exp: print g_A.a +PASS: gdb.cp/classes.exp: print g_A.x +PASS: gdb.cp/classes.exp: print g_B.b +PASS: gdb.cp/classes.exp: print g_B.x +PASS: gdb.cp/classes.exp: print g_C.c +PASS: gdb.cp/classes.exp: print g_C.x +PASS: gdb.cp/classes.exp: print g_D.d +PASS: gdb.cp/classes.exp: print g_D.x +PASS: gdb.cp/classes.exp: print g_E.e +PASS: gdb.cp/classes.exp: print g_E.x +PASS: gdb.cp/classes.exp: print g_A.b +PASS: gdb.cp/classes.exp: print g_B.c +PASS: gdb.cp/classes.exp: print g_B.d +PASS: gdb.cp/classes.exp: print g_C.b +PASS: gdb.cp/classes.exp: print g_C.d +PASS: gdb.cp/classes.exp: print g_D.e +PASS: gdb.cp/classes.exp: print g_A.y +PASS: gdb.cp/classes.exp: print g_B.z +PASS: gdb.cp/classes.exp: print g_C.q +PASS: gdb.cp/classes.exp: print g_D.p +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_B) +PASS: gdb.cp/classes.exp: unrelated class *param +PASS: gdb.cp/classes.exp: unrelated class ¶m +PASS: gdb.cp/classes.exp: unrelated class param +PASS: gdb.cp/classes.exp: continue to enums2(\(\)|) +PASS: gdb.cp/classes.exp: print obj_with_enum (1) +PASS: gdb.cp/classes.exp: next +PASS: gdb.cp/classes.exp: print obj_with_enum (2) +PASS: gdb.cp/classes.exp: print obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum +PASS: gdb.cp/classes.exp: print (ClassWithEnum::PrivEnum) 42 +PASS: gdb.cp/classes.exp: print ('ClassWithEnum::PrivEnum') 42 +PASS: gdb.cp/classes.exp: print Bar::z +PASS: gdb.cp/classes.exp: print &Foo::x +PASS: gdb.cp/classes.exp: print (int)&Foo::x +PASS: gdb.cp/classes.exp: print (int)&Bar::y == 2*sizeof(int) +PASS: gdb.cp/classes.exp: ptype Bar::z +PASS: gdb.cp/classes.exp: ptype &Bar::z +PASS: gdb.cp/classes.exp: print (int)pmi == sizeof(int) +PASS: gdb.cp/classes.exp: print Foo::st +PASS: gdb.cp/classes.exp: print bar.st +PASS: gdb.cp/classes.exp: print &foo.st +PASS: gdb.cp/classes.exp: print &Bar::st +PASS: gdb.cp/classes.exp: print *$ +PASS: gdb.cp/classes.exp: set print static-members off +PASS: gdb.cp/classes.exp: print csi without static members +PASS: gdb.cp/classes.exp: print cnsi without static members +PASS: gdb.cp/classes.exp: set print static-members on +PASS: gdb.cp/classes.exp: print csi with static members +PASS: gdb.cp/classes.exp: print cnsi with static members +PASS: gdb.cp/classes.exp: finish from marker_reg1 +PASS: gdb.cp/classes.exp: calling method for small class +FAIL: gdb.cp/classes.exp: print ctor of typedef class +FAIL: gdb.cp/classes.exp: print dtor of typedef class +PASS: gdb.cp/classes.exp: list ByAnyOtherName::times +Running ./gdb.cp/cmpd-minsyms.exp ... +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::a() const' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::b() volatile' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::c() const volatile' +PASS: gdb.cp/cmpd-minsyms.exp: set language c++ +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator == +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator==(GDB<int> const&) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<char>::harder(char) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::harder(int) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at "int GDB<char>::even_harder<int>(char)" +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::simple() +Running ./gdb.cp/converts.exp ... +PASS: gdb.cp/converts.exp: continue to breakpoint: end of main +PASS: gdb.cp/converts.exp: typedef to another typedef +PASS: gdb.cp/converts.exp: typedef to typedef of a typedef +PASS: gdb.cp/converts.exp: Pointer-to-pointer-to-pointer derived to Pointer-to-pointer-to-pointer base. +PASS: gdb.cp/converts.exp: pointer to pointer +PASS: gdb.cp/converts.exp: pointer to array +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to ancestor pointer +PASS: gdb.cp/converts.exp: pointer to void pointer +PASS: gdb.cp/converts.exp: pointer to void pointer pointer +PASS: gdb.cp/converts.exp: pointer to boolean +PASS: gdb.cp/converts.exp: pointer to long int +PASS: gdb.cp/converts.exp: pointer pointer to void pointer +PASS: gdb.cp/converts.exp: pointer pointer to pointer pointer +PASS: gdb.cp/converts.exp: pointer pointer to array of arrays +PASS: gdb.cp/converts.exp: pointer pointer to array of pointers +PASS: gdb.cp/converts.exp: pointer pointer to array of wrong pointers +PASS: gdb.cp/converts.exp: check all parameters for badness +PASS: gdb.cp/converts.exp: null pointer conversion +PASS: gdb.cp/converts.exp: p foo3_1 (0, 1) +PASS: gdb.cp/converts.exp: p foo3_1 (0, (const char**) 1) +PASS: gdb.cp/converts.exp: p foo3_2 (0, 0) +PASS: gdb.cp/converts.exp: p foo3_2 (0, (char const**) 0) +PASS: gdb.cp/converts.exp: p foo1_7(0) +PASS: gdb.cp/converts.exp: p foo1_7(integer) +PASS: gdb.cp/converts.exp: p foo1_7(long_int) +PASS: gdb.cp/converts.exp: p foo1_7(*a) +PASS: gdb.cp/converts.exp: p foo1_7(MY_A) +PASS: gdb.cp/converts.exp: p foo1_7(&foo1_7) +PASS: gdb.cp/converts.exp: p foo1_7(&A::member_) +PASS: gdb.cp/converts.exp: p foo1_7(a) +PASS: gdb.cp/converts.exp: p foo1_7(fp) +PASS: gdb.cp/converts.exp: p foo1_7(dp) +PASS: gdb.cp/converts.exp: p foo1_7(-1.23) +PASS: gdb.cp/converts.exp: p foo1_7(ta) +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: set check type off +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_2 (1,1) +Running ./gdb.cp/cpcompletion.exp ... +PASS: gdb.cp/cpcompletion.exp: complete class methods +PASS: gdb.cp/cpcompletion.exp: complete class methods beginning with F +PASS: gdb.cp/cpcompletion.exp: complete p foo1.g +PASS: gdb.cp/cpcompletion.exp: complete p foo1.base +PASS: gdb.cp/cpcompletion.exp: complete p foo1.Fo +PASS: gdb.cp/cpcompletion.exp: complete p a.g +Running ./gdb.cp/cpexprs.exp ... +PASS: gdb.cp/cpexprs.exp: set listsize 1 +PASS: gdb.cp/cpexprs.exp: print base1::a_function +FAIL: gdb.cp/cpexprs.exp: print base1::base1(int) +FAIL: gdb.cp/cpexprs.exp: print base1::base1(void) +PASS: gdb.cp/cpexprs.exp: print base2::a_function +FAIL: gdb.cp/cpexprs.exp: print base2::base2 +FAIL: gdb.cp/cpexprs.exp: print base::base(int) +FAIL: gdb.cp/cpexprs.exp: print base::base(void) +PASS: gdb.cp/cpexprs.exp: print base::operator char* +PASS: gdb.cp/cpexprs.exp: print base::operator delete +PASS: gdb.cp/cpexprs.exp: print base::operator delete[] +PASS: gdb.cp/cpexprs.exp: print base::operator fluff* +PASS: gdb.cp/cpexprs.exp: print base::operator fluff** +PASS: gdb.cp/cpexprs.exp: print base::operator int +PASS: gdb.cp/cpexprs.exp: print base::operator new +PASS: gdb.cp/cpexprs.exp: print base::operator new[] +PASS: gdb.cp/cpexprs.exp: print base::operator! +PASS: gdb.cp/cpexprs.exp: print base::operator!= +PASS: gdb.cp/cpexprs.exp: print base::operator% +PASS: gdb.cp/cpexprs.exp: print base::operator%= +PASS: gdb.cp/cpexprs.exp: print base::operator& +PASS: gdb.cp/cpexprs.exp: print base::operator&& +PASS: gdb.cp/cpexprs.exp: print base::operator&= +PASS: gdb.cp/cpexprs.exp: print base::operator() +PASS: gdb.cp/cpexprs.exp: print base::operator* +PASS: gdb.cp/cpexprs.exp: print base::operator*= +PASS: gdb.cp/cpexprs.exp: print base::operator+ +PASS: gdb.cp/cpexprs.exp: print base::operator++ +PASS: gdb.cp/cpexprs.exp: print base::operator+= +PASS: gdb.cp/cpexprs.exp: print base::operator- +PASS: gdb.cp/cpexprs.exp: print base::operator-- +PASS: gdb.cp/cpexprs.exp: print base::operator-= +PASS: gdb.cp/cpexprs.exp: print base::operator/ +PASS: gdb.cp/cpexprs.exp: print base::operator/= +PASS: gdb.cp/cpexprs.exp: print base::operator< +PASS: gdb.cp/cpexprs.exp: print base::operator<< +PASS: gdb.cp/cpexprs.exp: print base::operator<<= +PASS: gdb.cp/cpexprs.exp: print base::operator<= +PASS: gdb.cp/cpexprs.exp: print base::operator= +PASS: gdb.cp/cpexprs.exp: print base::operator== +PASS: gdb.cp/cpexprs.exp: print base::operator> +PASS: gdb.cp/cpexprs.exp: print base::operator>= +PASS: gdb.cp/cpexprs.exp: print base::operator>> +PASS: gdb.cp/cpexprs.exp: print base::operator>>= +PASS: gdb.cp/cpexprs.exp: print base::operator[] +PASS: gdb.cp/cpexprs.exp: print base::operator^ +PASS: gdb.cp/cpexprs.exp: print base::operator^= +PASS: gdb.cp/cpexprs.exp: print base::operator| +PASS: gdb.cp/cpexprs.exp: print base::operator|= +PASS: gdb.cp/cpexprs.exp: print base::operator|| +PASS: gdb.cp/cpexprs.exp: print base::operator~ +PASS: gdb.cp/cpexprs.exp: print base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: print base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: print base::overload(int) const +PASS: gdb.cp/cpexprs.exp: print base::overload(long) const +PASS: gdb.cp/cpexprs.exp: print base::overload(short) const +PASS: gdb.cp/cpexprs.exp: print base::overload(void) const +FAIL: gdb.cp/cpexprs.exp: print base::~base +PASS: gdb.cp/cpexprs.exp: print derived::a_function +FAIL: gdb.cp/cpexprs.exp: print derived::derived +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print policy1::function +FAIL: gdb.cp/cpexprs.exp: print policy1::policy +PASS: gdb.cp/cpexprs.exp: print policy2::function +FAIL: gdb.cp/cpexprs.exp: print policy2::policy +PASS: gdb.cp/cpexprs.exp: print policy3::function +FAIL: gdb.cp/cpexprs.exp: print policy3::policy +PASS: gdb.cp/cpexprs.exp: print policy4::function +FAIL: gdb.cp/cpexprs.exp: print policy4::policy +PASS: gdb.cp/cpexprs.exp: print policyd1::function +FAIL: gdb.cp/cpexprs.exp: print policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd2::function +FAIL: gdb.cp/cpexprs.exp: print policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd3::function +FAIL: gdb.cp/cpexprs.exp: print policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd4::function +FAIL: gdb.cp/cpexprs.exp: print policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd5::function +FAIL: gdb.cp/cpexprs.exp: print policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::~policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: print tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: print test_function +PASS: gdb.cp/cpexprs.exp: list base1::a_function +PASS: gdb.cp/cpexprs.exp: list base1::base1(int) +PASS: gdb.cp/cpexprs.exp: list base1::base1(void) +PASS: gdb.cp/cpexprs.exp: list base2::a_function +PASS: gdb.cp/cpexprs.exp: list base2::base2 +PASS: gdb.cp/cpexprs.exp: list base::base(int) +PASS: gdb.cp/cpexprs.exp: list base::base(void) +PASS: gdb.cp/cpexprs.exp: list base::operator char* +PASS: gdb.cp/cpexprs.exp: list base::operator delete +PASS: gdb.cp/cpexprs.exp: list base::operator delete[] +PASS: gdb.cp/cpexprs.exp: list base::operator fluff* +PASS: gdb.cp/cpexprs.exp: list base::operator fluff** +PASS: gdb.cp/cpexprs.exp: list base::operator int +PASS: gdb.cp/cpexprs.exp: list base::operator new +PASS: gdb.cp/cpexprs.exp: list base::operator new[] +PASS: gdb.cp/cpexprs.exp: list base::operator! +PASS: gdb.cp/cpexprs.exp: list base::operator!= +PASS: gdb.cp/cpexprs.exp: list base::operator% +PASS: gdb.cp/cpexprs.exp: list base::operator%= +PASS: gdb.cp/cpexprs.exp: list base::operator& +PASS: gdb.cp/cpexprs.exp: list base::operator&& +PASS: gdb.cp/cpexprs.exp: list base::operator&= +PASS: gdb.cp/cpexprs.exp: list base::operator() +PASS: gdb.cp/cpexprs.exp: list base::operator* +PASS: gdb.cp/cpexprs.exp: list base::operator*= +PASS: gdb.cp/cpexprs.exp: list base::operator+ +PASS: gdb.cp/cpexprs.exp: list base::operator++ +PASS: gdb.cp/cpexprs.exp: list base::operator+= +PASS: gdb.cp/cpexprs.exp: list base::operator- +PASS: gdb.cp/cpexprs.exp: list base::operator-- +PASS: gdb.cp/cpexprs.exp: list base::operator-= +PASS: gdb.cp/cpexprs.exp: list base::operator/ +PASS: gdb.cp/cpexprs.exp: list base::operator/= +PASS: gdb.cp/cpexprs.exp: list base::operator< +PASS: gdb.cp/cpexprs.exp: list base::operator<< +PASS: gdb.cp/cpexprs.exp: list base::operator<<= +PASS: gdb.cp/cpexprs.exp: list base::operator<= +PASS: gdb.cp/cpexprs.exp: list base::operator= +PASS: gdb.cp/cpexprs.exp: list base::operator== +PASS: gdb.cp/cpexprs.exp: list base::operator> +PASS: gdb.cp/cpexprs.exp: list base::operator>= +PASS: gdb.cp/cpexprs.exp: list base::operator>> +PASS: gdb.cp/cpexprs.exp: list base::operator>>= +PASS: gdb.cp/cpexprs.exp: list base::operator[] +PASS: gdb.cp/cpexprs.exp: list base::operator^ +PASS: gdb.cp/cpexprs.exp: list base::operator^= +PASS: gdb.cp/cpexprs.exp: list base::operator| +PASS: gdb.cp/cpexprs.exp: list base::operator|= +PASS: gdb.cp/cpexprs.exp: list base::operator|| +PASS: gdb.cp/cpexprs.exp: list base::operator~ +PASS: gdb.cp/cpexprs.exp: list base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: list base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: list base::overload(int) const +PASS: gdb.cp/cpexprs.exp: list base::overload(long) const +PASS: gdb.cp/cpexprs.exp: list base::overload(short) const +PASS: gdb.cp/cpexprs.exp: list base::overload(void) const +PASS: gdb.cp/cpexprs.exp: list base::~base +PASS: gdb.cp/cpexprs.exp: list derived::a_function +PASS: gdb.cp/cpexprs.exp: list derived::derived +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list policy1::function +PASS: gdb.cp/cpexprs.exp: list policy1::policy +PASS: gdb.cp/cpexprs.exp: list policy2::function +PASS: gdb.cp/cpexprs.exp: list policy2::policy +PASS: gdb.cp/cpexprs.exp: list policy3::function +PASS: gdb.cp/cpexprs.exp: list policy3::policy +PASS: gdb.cp/cpexprs.exp: list policy4::function +PASS: gdb.cp/cpexprs.exp: list policy4::policy +PASS: gdb.cp/cpexprs.exp: list policyd1::function +PASS: gdb.cp/cpexprs.exp: list policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd2::function +PASS: gdb.cp/cpexprs.exp: list policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd3::function +PASS: gdb.cp/cpexprs.exp: list policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd4::function +PASS: gdb.cp/cpexprs.exp: list policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd5::function +PASS: gdb.cp/cpexprs.exp: list policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: list tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: list test_function +PASS: gdb.cp/cpexprs.exp: continue to base1::a_function +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(int) +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(void) +PASS: gdb.cp/cpexprs.exp: continue to base2::a_function +PASS: gdb.cp/cpexprs.exp: continue to base2::base2 +PASS: gdb.cp/cpexprs.exp: continue to base::base(int) +PASS: gdb.cp/cpexprs.exp: continue to base::base(void) +PASS: gdb.cp/cpexprs.exp: continue to base::operator char* +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff* +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff** +PASS: gdb.cp/cpexprs.exp: continue to base::operator int +PASS: gdb.cp/cpexprs.exp: continue to base::operator new +PASS: gdb.cp/cpexprs.exp: continue to base::operator new[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator! +PASS: gdb.cp/cpexprs.exp: continue to base::operator!= +PASS: gdb.cp/cpexprs.exp: continue to base::operator% +PASS: gdb.cp/cpexprs.exp: continue to base::operator%= +PASS: gdb.cp/cpexprs.exp: continue to base::operator& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&= +PASS: gdb.cp/cpexprs.exp: continue to base::operator() +PASS: gdb.cp/cpexprs.exp: continue to base::operator* +PASS: gdb.cp/cpexprs.exp: continue to base::operator*= +PASS: gdb.cp/cpexprs.exp: continue to base::operator+ +PASS: gdb.cp/cpexprs.exp: continue to base::operator++ +PASS: gdb.cp/cpexprs.exp: continue to base::operator+= +PASS: gdb.cp/cpexprs.exp: continue to base::operator- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-= +PASS: gdb.cp/cpexprs.exp: continue to base::operator/ +PASS: gdb.cp/cpexprs.exp: continue to base::operator/= +PASS: gdb.cp/cpexprs.exp: continue to base::operator< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator= +PASS: gdb.cp/cpexprs.exp: continue to base::operator== +PASS: gdb.cp/cpexprs.exp: continue to base::operator> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator>> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator^ +PASS: gdb.cp/cpexprs.exp: continue to base::operator^= +PASS: gdb.cp/cpexprs.exp: continue to base::operator| +PASS: gdb.cp/cpexprs.exp: continue to base::operator|= +PASS: gdb.cp/cpexprs.exp: continue to base::operator|| +PASS: gdb.cp/cpexprs.exp: continue to base::operator~ +PASS: gdb.cp/cpexprs.exp: continue to base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(int) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(long) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(short) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(void) const +PASS: gdb.cp/cpexprs.exp: continue to base::~base +PASS: gdb.cp/cpexprs.exp: continue to derived::a_function +PASS: gdb.cp/cpexprs.exp: continue to derived::derived +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to policy1::function +PASS: gdb.cp/cpexprs.exp: continue to policy1::policy +PASS: gdb.cp/cpexprs.exp: continue to policy2::function +PASS: gdb.cp/cpexprs.exp: continue to policy2::policy +PASS: gdb.cp/cpexprs.exp: continue to policy3::function +PASS: gdb.cp/cpexprs.exp: continue to policy3::policy +PASS: gdb.cp/cpexprs.exp: continue to policy4::function +PASS: gdb.cp/cpexprs.exp: continue to policy4::policy +PASS: gdb.cp/cpexprs.exp: continue to policyd1::function +PASS: gdb.cp/cpexprs.exp: continue to policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd1::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd2::function +PASS: gdb.cp/cpexprs.exp: continue to policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd2::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd3::function +PASS: gdb.cp/cpexprs.exp: continue to policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd3::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd4::function +PASS: gdb.cp/cpexprs.exp: continue to policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd4::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd5::function +PASS: gdb.cp/cpexprs.exp: continue to policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd5::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int)' +PASS: gdb.cp/cpexprs.exp: p CV::m(int) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p CV_f(int) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::t) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::i) +Running ./gdb.cp/cplabel.exp ... +PASS: gdb.cp/cplabel.exp: break foo::bar:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::bar:get_out_of_here +PASS: gdb.cp/cplabel.exp: break foo::baz:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::baz:get_out_of_here +Running ./gdb.cp/cplusfuncs.exp ... +PASS: gdb.cp/cplusfuncs.exp: set width 0 +PASS: gdb.cp/cplusfuncs.exp: set language c++ +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_comma +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_foo_ref +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_int_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_int +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_typedef +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(void)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(signed char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(float)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(double)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator++(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator,(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator==(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator||(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator~(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator--(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator[](foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator()(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new[] +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator int(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator char*(void) +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc1 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc2 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc3 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc4 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc5 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc6 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc7 +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator++(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator,(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator==(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator||(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator~(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator--(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\[\](" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator new(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator delete(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator int(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator()(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator char\*(" +PASS: gdb.cp/cplusfuncs.exp: list foo::operator int* +Running ./gdb.cp/cp-relocate.exp ... +PASS: gdb.cp/cp-relocate.exp: info functions +PASS: gdb.cp/cp-relocate.exp: get address of func<1>(int) +PASS: gdb.cp/cp-relocate.exp: get address of func<2>(int) +PASS: gdb.cp/cp-relocate.exp: get address of caller +PASS: gdb.cp/cp-relocate.exp: C++ functions have different addresses +PASS: gdb.cp/cp-relocate.exp: info file +PASS: gdb.cp/cp-relocate.exp: add-symbol-file cp-relocate.o +PASS: gdb.cp/cp-relocate.exp: break *func<1>(int) +PASS: gdb.cp/cp-relocate.exp: break *func<2>(int) +Running ./gdb.cp/ctti.exp ... +PASS: gdb.cp/ctti.exp: continue to breakpoint: marker add1 +PASS: gdb.cp/ctti.exp: print c +PASS: gdb.cp/ctti.exp: print f +PASS: gdb.cp/ctti.exp: print i +Running ./gdb.cp/debug-expr.exp ... +PASS: gdb.cp/debug-expr.exp: set language c++ +PASS: gdb.cp/debug-expr.exp: set debug expression 1 +PASS: gdb.cp/debug-expr.exp: print static_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print reinterpret_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print dynamic_cast<void*>(0) +Running ./gdb.cp/demangle.exp ... +PASS: gdb.cp/demangle.exp: set language c++ +PASS: gdb.cp/demangle.exp: set width 0 +PASS: gdb.cp/demangle.exp: lucid: set demangle-style +PASS: gdb.cp/demangle.exp: lucid: check demangling style +PASS: gdb.cp/demangle.exp: lucid: WS__FR7istream +PASS: gdb.cp/demangle.exp: lucid: __aa__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __aad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aer__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __als__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amd__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ami__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aor__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __apl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ars__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFR7istream +PASS: gdb.cp/demangle.exp: lucid: __as__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__3iosFR3ios +PASS: gdb.cp/demangle.exp: lucid: __cl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __cm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __co__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPc +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPci +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFPciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10smanip_intFPFR3iosi_R3iosi +PASS: gdb.cp/demangle.exp: lucid: __ct__11c_exceptionFPcRC7complexT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFv +PASS: gdb.cp/demangle.exp: lucid: __ct__11smanip_longFPFR3iosl_R3iosl +PASS: gdb.cp/demangle.exp: lucid: __ct__11stdiostreamFP4FILE +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPFl_PvPFPv_v +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPUciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFi +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFv +PASS: gdb.cp/demangle.exp: lucid: __ct__13strstreambaseFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiN31 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiPCc +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: __ct__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7filebufFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambufiP7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiT1P7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFiPc +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __ct__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dl__3fooSFPv +PASS: gdb.cp/demangle.exp: lucid: __dl__FPv +PASS: gdb.cp/demangle.exp: lucid: __dt__10istrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __dv__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __er__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ge__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __gt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __le__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPCc +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPv +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUl +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFd +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFl +PASS: gdb.cp/demangle.exp: lucid: __ls__FR7ostream7complex +PASS: gdb.cp/demangle.exp: lucid: __lt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __md__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __mi__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __mm__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ne__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __nt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __nw__3fooSFi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUiPv +PASS: gdb.cp/demangle.exp: lucid: __oo__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __opPc__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __opi__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __or__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pp__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __pt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __rm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR7istream_R7istream +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPUc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUs +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRd +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRs +PASS: gdb.cp/demangle.exp: lucid: __rs__FR7istreamR7complex +PASS: gdb.cp/demangle.exp: lucid: __vc__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __vtbl__10istrstream +PASS: gdb.cp/demangle.exp: lucid: __vtbl__17ostream__iostream__19iostream_withassign +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios__13strstreambase +KFAIL: gdb.cp/demangle.exp: lucid: __vtbl__3foo__vt_cc_main_ (PRMS: gdb/945) +PASS: gdb.cp/demangle.exp: lucid: abs__F7complex +PASS: gdb.cp/demangle.exp: lucid: allocate__9streambufFv +PASS: gdb.cp/demangle.exp: lucid: attach__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: bitalloc__3iosSFv +PASS: gdb.cp/demangle.exp: lucid: chr__FiT1 +PASS: gdb.cp/demangle.exp: lucid: complex_error__FR11c_exception +PASS: gdb.cp/demangle.exp: lucid: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complicated_put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: conv10__FlPc +PASS: gdb.cp/demangle.exp: lucid: conv16__FUlPc +PASS: gdb.cp/demangle.exp: lucid: dec__FR3ios +PASS: gdb.cp/demangle.exp: lucid: dec__Fli +PASS: gdb.cp/demangle.exp: lucid: dofield__FP7ostreamPciT2T3 +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFl +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFv +PASS: gdb.cp/demangle.exp: lucid: foo__FiN31 +PASS: gdb.cp/demangle.exp: lucid: foo__FiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: foo___3barFl +PASS: gdb.cp/demangle.exp: lucid: form__FPCce +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFR9streambufc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPUcic +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: ignore__7istreamFiT1 +PASS: gdb.cp/demangle.exp: lucid: init__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: init__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: initcount__13Iostream_init +PASS: gdb.cp/demangle.exp: lucid: ipfx__7istreamFi +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFUc +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: open__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: open__7filebufFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FSc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fd +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Ff +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fv +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN21 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN31 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN41 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN51 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN61 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN71 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN81 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91N11 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiT1 +PASS: gdb.cp/demangle.exp: lucid: polar__FdT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexd +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexi +PASS: gdb.cp/demangle.exp: lucid: pow__Fd7complex +PASS: gdb.cp/demangle.exp: lucid: pstart__FPciT2 +PASS: gdb.cp/demangle.exp: lucid: put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: read__7istreamFPci +PASS: gdb.cp/demangle.exp: lucid: resetiosflags__FR3iosl +PASS: gdb.cp/demangle.exp: lucid: restore_errno__FRi +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: seekg__7istreamFl8seek_dir +PASS: gdb.cp/demangle.exp: lucid: seekoff__12strstreambufFl8seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekpos__9streambufFli +PASS: gdb.cp/demangle.exp: lucid: set_new_handler__FPFv_v +PASS: gdb.cp/demangle.exp: lucid: setb__9streambufFPcT1i +PASS: gdb.cp/demangle.exp: lucid: setb__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setbuf__11fstreambaseFPci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPUci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPciT2 +PASS: gdb.cp/demangle.exp: lucid: setf__3iosFlT1 +PASS: gdb.cp/demangle.exp: lucid: setfill__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setg__9streambufFPcN21 +PASS: gdb.cp/demangle.exp: lucid: setp__9streambufFPcT1 +PASS: gdb.cp/demangle.exp: lucid: sputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: str__FPCci +PASS: gdb.cp/demangle.exp: lucid: tie__3iosFP7ostream +PASS: gdb.cp/demangle.exp: lucid: uconv10__FUlPc +PASS: gdb.cp/demangle.exp: lucid: write__7ostreamFPCci +PASS: gdb.cp/demangle.exp: lucid: xget__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: xsgetn__9streambufFPci +PASS: gdb.cp/demangle.exp: lucid: xsputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: set demangle-style +PASS: gdb.cp/demangle.exp: gnu: check demangling style +PASS: gdb.cp/demangle.exp: gnu: Abort__FP6EditoriPCc +PASS: gdb.cp/demangle.exp: gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue +PASS: gdb.cp/demangle.exp: gnu: Append__15NameChooserViewPCc +PASS: gdb.cp/demangle.exp: gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic +PASS: gdb.cp/demangle.exp: gnu: AtEnd__13ivRubberGroup +PASS: gdb.cp/demangle.exp: gnu: BgFilter__9ivTSolverP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: BitPatterntoa__FRC10BitPatternccc +PASS: gdb.cp/demangle.exp: gnu: Check__6UArrayi +PASS: gdb.cp/demangle.exp: gnu: CoreConstDecls__8TextCodeR7ostream +PASS: gdb.cp/demangle.exp: gnu: Detach__8StateVarP12StateVarView +PASS: gdb.cp/demangle.exp: gnu: Done__9ComponentG8Iterator +PASS: gdb.cp/demangle.exp: gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii +PASS: gdb.cp/demangle.exp: gnu: Edit__12StringEditorPCcii +PASS: gdb.cp/demangle.exp: gnu: Effect__11RelateManipR7ivEvent +PASS: gdb.cp/demangle.exp: gnu: FilterName__FPCc +PASS: gdb.cp/demangle.exp: gnu: Filter__6PSTextPCci +PASS: gdb.cp/demangle.exp: gnu: FindColor__7CatalogPCciii +PASS: gdb.cp/demangle.exp: gnu: FindFixed__FRP4CNetP4CNet +PASS: gdb.cp/demangle.exp: gnu: FindFont__7CatalogPCcN21 +PASS: gdb.cp/demangle.exp: gnu: Fix48_abort__FR8twolongs +PASS: gdb.cp/demangle.exp: gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2 +PASS: gdb.cp/demangle.exp: gnu: GetBgColor__C9ivPainter +PASS: gdb.cp/demangle.exp: gnu: Iisdouble__FPC6IntRep +PASS: gdb.cp/demangle.exp: gnu: InsertBody__15H_PullrightMenuii +PASS: gdb.cp/demangle.exp: gnu: InsertCharacter__9TextManipc +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1 +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi +PASS: gdb.cp/demangle.exp: gnu: IsADirectory__FPCcR4stat +PASS: gdb.cp/demangle.exp: gnu: IsAGroup__FP11GraphicViewP11GraphicComp +PASS: gdb.cp/demangle.exp: gnu: IsA__10ButtonCodeUl +PASS: gdb.cp/demangle.exp: gnu: ReadName__FR7istreamPc +PASS: gdb.cp/demangle.exp: gnu: Redraw__13StringBrowseriiii +PASS: gdb.cp/demangle.exp: gnu: Rotate__13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Rotated__C13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Round__Ff +PASS: gdb.cp/demangle.exp: gnu: SetExport__16MemberSharedNameUi +PASS: gdb.cp/demangle.exp: gnu: Set__14ivControlState13ControlStatusUi +PASS: gdb.cp/demangle.exp: gnu: Set__5DFacePcii +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2 +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement +PASS: gdb.cp/demangle.exp: gnu: VOrder__9ivTSolverUiRP12ivInteractorT2 +PASS: gdb.cp/demangle.exp: gnu: Valid__7CatalogPCcRP4Tool +PASS: gdb.cp/demangle.exp: gnu: _10PageButton$__both +PASS: gdb.cp/demangle.exp: gnu: _3RNG$singleMantissa +PASS: gdb.cp/demangle.exp: gnu: _5IComp$_release +PASS: gdb.cp/demangle.exp: gnu: _$_10BitmapComp +PASS: gdb.cp/demangle.exp: gnu: _$_9__io_defs +PASS: gdb.cp/demangle.exp: gnu: _$_Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: _$_Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __10ivTelltaleiP7ivGlyph +PASS: gdb.cp/demangle.exp: gnu: __10ivViewportiP12ivInteractorUi +PASS: gdb.cp/demangle.exp: gnu: __10ostrstream +PASS: gdb.cp/demangle.exp: gnu: __10ostrstreamPcii +PASS: gdb.cp/demangle.exp: gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui +PASS: gdb.cp/demangle.exp: gnu: __11BitmapTablei +PASS: gdb.cp/demangle.exp: gnu: __12ViewportCodeP12ViewportComp +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_BorderiPCci +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_Borderii +PASS: gdb.cp/demangle.exp: gnu: __12ivBackgroundiP7ivGlyphPC7ivColor +PASS: gdb.cp/demangle.exp: gnu: __12ivBreak_Listl +PASS: gdb.cp/demangle.exp: gnu: __14TextInteractoriPCcUi +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiPCcP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __20DisplayList_IteratorR11DisplayList +PASS: gdb.cp/demangle.exp: gnu: __3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __3fooiN31 +PASS: gdb.cp/demangle.exp: gnu: __3fooiPCc +PASS: gdb.cp/demangle.exp: gnu: __3fooiRT0iT2iT2 +PASS: gdb.cp/demangle.exp: gnu: __6GetOptiPPcPCc +PASS: gdb.cp/demangle.exp: gnu: __6KeyMapPT0 +PASS: gdb.cp/demangle.exp: gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData +PASS: gdb.cp/demangle.exp: gnu: __7procbufPCci +PASS: gdb.cp/demangle.exp: gnu: __8ArrowCmdP6EditorUiUi +PASS: gdb.cp/demangle.exp: gnu: __9F_EllipseiiiiP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __9FrameDataP9FrameCompi +PASS: gdb.cp/demangle.exp: gnu: __9HVGraphicP9CanvasVarP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: __Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __aa__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __adv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aer__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __als__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __amd__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ami__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__3FixRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix16i +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix32RT0 +PASS: gdb.cp/demangle.exp: gnu: __aor__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __apl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ars__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __as__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__6Normal +PASS: gdb.cp/demangle.exp: gnu: __cl__6Stringii +PASS: gdb.cp/demangle.exp: gnu: __cm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __co__3foo +PASS: gdb.cp/demangle.exp: gnu: __dl__3fooPv +PASS: gdb.cp/demangle.exp: gnu: __dv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __er__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ge__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __gt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __le__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamR3Fix +PASS: gdb.cp/demangle.exp: gnu: __lt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __md__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mi__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ml__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mm__3fooi +PASS: gdb.cp/demangle.exp: gnu: __ne__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7ComplexT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7Complexd +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC9SubStringRC6String +PASS: gdb.cp/demangle.exp: gnu: __nt__3foo +PASS: gdb.cp/demangle.exp: gnu: __nw__3fooi +PASS: gdb.cp/demangle.exp: gnu: __oo__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __opPc__3foo +PASS: gdb.cp/demangle.exp: gnu: __opi__3foo +PASS: gdb.cp/demangle.exp: gnu: __or__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pp__3fooi +PASS: gdb.cp/demangle.exp: gnu: __rf__3foo +PASS: gdb.cp/demangle.exp: gnu: __rm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __rs__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __vc__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: _gsub__6StringRC5RegexPCci +PASS: gdb.cp/demangle.exp: gnu: _new_Fix__FUs +PASS: gdb.cp/demangle.exp: gnu: _vt.foo +PASS: gdb.cp/demangle.exp: gnu: _vt.foo.bar +PASS: gdb.cp/demangle.exp: gnu: _vt$foo +PASS: gdb.cp/demangle.exp: gnu: _vt$foo$bar +PASS: gdb.cp/demangle.exp: gnu: append__7ivGlyphPT0 +PASS: gdb.cp/demangle.exp: gnu: arg__FRC7Complex +PASS: gdb.cp/demangle.exp: gnu: clearok__FP7_win_sti +PASS: gdb.cp/demangle.exp: gnu: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC10BitPattern +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC12BitSubStringi +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRT0 +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntRepT0P6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntReplP6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FRC8RationalT0R8Rational +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerT0R7IntegerT2 +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerlR7IntegerRl +PASS: gdb.cp/demangle.exp: gnu: enable__14DocumentViewerPCcUi +PASS: gdb.cp/demangle.exp: gnu: foo__FiN30 +PASS: gdb.cp/demangle.exp: gnu: foo__FiR3fooiT1iT1 +PASS: gdb.cp/demangle.exp: gnu: foo___3barl +PASS: gdb.cp/demangle.exp: gnu: insert__15ivClippingStacklRP8_XRegion +PASS: gdb.cp/demangle.exp: gnu: insert__16ChooserInfo_ListlR11ChooserInfo +PASS: gdb.cp/demangle.exp: gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep +PASS: gdb.cp/demangle.exp: gnu: leaveok__FP7_win_stc +PASS: gdb.cp/demangle.exp: gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle +PASS: gdb.cp/demangle.exp: gnu: matches__C9BitStringRC10BitPatterni +PASS: gdb.cp/demangle.exp: gnu: matches__C9SubStringRC5Regex +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FSc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fd +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Ff +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fv +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fi +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit +PASS: gdb.cp/demangle.exp: gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation +PASS: gdb.cp/demangle.exp: gnu: poke__8ivRasterUlUlffff +PASS: gdb.cp/demangle.exp: gnu: polar__Fdd +PASS: gdb.cp/demangle.exp: gnu: read__10osStdInputRPCc +PASS: gdb.cp/demangle.exp: gnu: scale__13ivTransformerff +PASS: gdb.cp/demangle.exp: gnu: scanw__12CursesWindowPCce +PASS: gdb.cp/demangle.exp: gnu: scmp__FPCcT0 +PASS: gdb.cp/demangle.exp: gnu: sgetn__7filebufPci +PASS: gdb.cp/demangle.exp: gnu: shift__FP5_FrepiT0 +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSeti +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSetii +PASS: gdb.cp/demangle.exp: gnu: testbit__FRC7Integerl +PASS: gdb.cp/demangle.exp: gnu: text_source__8Documentl +PASS: gdb.cp/demangle.exp: gnu: variance__6Erlangd +PASS: gdb.cp/demangle.exp: gnu: vform__8iostreamPCcPc +PASS: gdb.cp/demangle.exp: gnu: view__14DocumentViewerP8ItemViewP11TabularItem +PASS: gdb.cp/demangle.exp: gnu: xy_extents__11ivExtensionffff +PASS: gdb.cp/demangle.exp: gnu: zero__8osMemoryPvUi +PASS: gdb.cp/demangle.exp: gnu: _2T4$N +PASS: gdb.cp/demangle.exp: gnu: _Q22T42t1$N +PASS: gdb.cp/demangle.exp: gnu: get__2T1 +PASS: gdb.cp/demangle.exp: gnu: get__Q22T11a +PASS: gdb.cp/demangle.exp: gnu: get__Q32T11a1b +PASS: gdb.cp/demangle.exp: gnu: get__Q42T11a1b1c +PASS: gdb.cp/demangle.exp: gnu: get__Q52T11a1b1c1d +PASS: gdb.cp/demangle.exp: gnu: put__2T1i +PASS: gdb.cp/demangle.exp: gnu: put__Q22T11ai +PASS: gdb.cp/demangle.exp: gnu: put__Q32T11a1bi +PASS: gdb.cp/demangle.exp: gnu: put__Q42T11a1b1ci +PASS: gdb.cp/demangle.exp: gnu: put__Q52T11a1b1c1di +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPCv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPCv +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRC3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooR3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11ZcUi +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11Z1tUi +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11ZcPv +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11Z1tPv +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zci +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zc +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1ti +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1t +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0 +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$D$set +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$I$set +PASS: gdb.cp/demangle.exp: gnu: __as__t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCUiPT0 +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi +PASS: gdb.cp/demangle.exp: gnu: __t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t8ListElem1Z5LabelRt4List1Z5Label +PASS: gdb.cp/demangle.exp: gnu: __t8BDDHookV1ZPcRCPc +PASS: gdb.cp/demangle.exp: gnu: _vt$t8BDDHookV1ZPc +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: __eq__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters +PASS: gdb.cp/demangle.exp: gnu: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: foo__I40 +PASS: gdb.cp/demangle.exp: gnu: foo__I_200_ +PASS: gdb.cp/demangle.exp: gnu: foo__I_200 +PASS: gdb.cp/demangle.exp: gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000 +PASS: gdb.cp/demangle.exp: gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator +PASS: gdb.cp/demangle.exp: arm: set demangle-style +PASS: gdb.cp/demangle.exp: arm: check demangling style +PASS: gdb.cp/demangle.exp: arm: __dt__21T5__pt__11_PFiPPdPv_iFv +PASS: gdb.cp/demangle.exp: arm: __ct__1cFi +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_iFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: arm: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: arm: __dt__12T5__pt__3_1xFv +PASS: gdb.cp/demangle.exp: arm: __dt__17T5__pt__8_PFcPv_iFv +PASS: gdb.cp/demangle.exp: arm: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: arm: __ct__21T5__pt__11_PFiPPdPv_iFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: arm: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: arm: put__2T7SFi +PASS: gdb.cp/demangle.exp: arm: __dl__12T5__pt__3_1xSFPv +PASS: gdb.cp/demangle.exp: arm: h__FUc +PASS: gdb.cp/demangle.exp: arm: f__Fic +PASS: gdb.cp/demangle.exp: arm: h__FUi +PASS: gdb.cp/demangle.exp: arm: h__Fci +PASS: gdb.cp/demangle.exp: arm: h__FUl +PASS: gdb.cp/demangle.exp: arm: h__Fcl +PASS: gdb.cp/demangle.exp: arm: h__FUs +PASS: gdb.cp/demangle.exp: arm: h__Fcs +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: arm: X__12T5__pt__3_1x +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: arm: h__FcT1 +PASS: gdb.cp/demangle.exp: arm: f__Ficd +PASS: gdb.cp/demangle.exp: arm: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: arm: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: arm: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: arm: __dl__17T5__pt__8_PFcPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: printf__FPCce +PASS: gdb.cp/demangle.exp: arm: X__17T5__pt__8_PFcPv_i +PASS: gdb.cp/demangle.exp: arm: __ct__12T5__pt__3_1xFi +PASS: gdb.cp/demangle.exp: arm: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: __std__foo +PASS: gdb.cp/demangle.exp: arm: __sti__bar +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: arm: get__2T7SFv +PASS: gdb.cp/demangle.exp: arm: X__21T5__pt__11_PFiPPdPv_i +PASS: gdb.cp/demangle.exp: arm: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_iSFPv +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: h__Fc +PASS: gdb.cp/demangle.exp: arm: h__Fd +PASS: gdb.cp/demangle.exp: arm: h__Ff +PASS: gdb.cp/demangle.exp: arm: h__Fi +PASS: gdb.cp/demangle.exp: arm: f__Fi +PASS: gdb.cp/demangle.exp: arm: h__Fl +PASS: gdb.cp/demangle.exp: arm: h__Fs +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_c +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_i +PASS: gdb.cp/demangle.exp: arm: g__FdCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FfCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FlClT1 +PASS: gdb.cp/demangle.exp: arm: g__FiCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FsCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FcCcT1 +PASS: gdb.cp/demangle.exp: arm: __ct__17T5__pt__8_PFcPv_iFi +PASS: gdb.cp/demangle.exp: arm: f__FicdPc +PASS: gdb.cp/demangle.exp: arm: __nw__FUi +PASS: gdb.cp/demangle.exp: arm: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: arm: put__2T1SFi +PASS: gdb.cp/demangle.exp: arm: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: arm: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: arm: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: arm: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: arm: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: arm: get__2T1SFv +PASS: gdb.cp/demangle.exp: arm: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __dt__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__12T1__pt__3_1tSFPv +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFi +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__11T1__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2 +PASS: gdb.cp/demangle.exp: arm: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: arm: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: hp: set demangle-style +PASS: gdb.cp/demangle.exp: hp: check demangling style +PASS: gdb.cp/demangle.exp: hp: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: hp: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: hp: put__2T7SFi +PASS: gdb.cp/demangle.exp: hp: h__FUc +PASS: gdb.cp/demangle.exp: hp: f__Fic +PASS: gdb.cp/demangle.exp: hp: h__FUi +PASS: gdb.cp/demangle.exp: hp: h__Fci +PASS: gdb.cp/demangle.exp: hp: h__FUl +PASS: gdb.cp/demangle.exp: hp: h__Fcl +PASS: gdb.cp/demangle.exp: hp: h__FUs +PASS: gdb.cp/demangle.exp: hp: h__Fcs +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: hp: h__FcT1 +PASS: gdb.cp/demangle.exp: hp: f__Ficd +PASS: gdb.cp/demangle.exp: hp: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: hp: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: hp: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: hp: printf__FPCce +PASS: gdb.cp/demangle.exp: hp: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: hp: get__2T7SFv +PASS: gdb.cp/demangle.exp: hp: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: hp: h__Fc +PASS: gdb.cp/demangle.exp: hp: h__Fd +PASS: gdb.cp/demangle.exp: hp: h__Ff +PASS: gdb.cp/demangle.exp: hp: h__Fi +PASS: gdb.cp/demangle.exp: hp: f__Fi +PASS: gdb.cp/demangle.exp: hp: h__Fl +PASS: gdb.cp/demangle.exp: hp: h__Fs +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FdCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FfCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FlClT1 +PASS: gdb.cp/demangle.exp: hp: g__FiCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FsCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FcCcT1 +PASS: gdb.cp/demangle.exp: hp: f__FicdPc +PASS: gdb.cp/demangle.exp: hp: __nw__FUi +PASS: gdb.cp/demangle.exp: hp: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: hp: put__2T1SFi +PASS: gdb.cp/demangle.exp: hp: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: hp: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: hp: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: hp: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: hp: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: hp: get__2T1SFv +PASS: gdb.cp/demangle.exp: hp: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: hp: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFiPPdPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__1cFi +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTi__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XT1x__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFcPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFiPPdPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XT1x__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XT1x +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFcPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFcPv_i +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XT1x__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFiPPdPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFiPPdPv_i +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTi__SFPv +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTc +PASS: gdb.cp/demangle.exp: hp: X__2T5XTi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XT1t__SFPv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiUP34__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXUP2701Td__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSP334__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSM__SCFPPd +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67UP4000TRs__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67TRdTFPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: X__6vectorXTiSN67TdTPvUP5TRs +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3foo__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN42A3foo__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_2 +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_19 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v_34 +PASS: gdb.cp/demangle.exp: hp: spec__13Spec<%1,%1.*>XTiTPi_FPi +PASS: gdb.cp/demangle.exp: hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi +PASS: gdb.cp/demangle.exp: hp: add__XTc_FcT1 +PASS: gdb.cp/demangle.exp: hp: add__XTcSP9A5label_FcPPlT1 +PASS: gdb.cp/demangle.exp: hp: add__XTPfTFPd_f_FcT1 +PASS: gdb.cp/demangle.exp: hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv +PASS: gdb.cp/demangle.exp: hp: _Utf390_1__1_9223372036854775807__9223372036854775 +Running ./gdb.cp/derivation.exp ... +PASS: gdb.cp/derivation.exp: before run: ptype A::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A::value_type +PASS: gdb.cp/derivation.exp: before run: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D::value_type +PASS: gdb.cp/derivation.exp: before run: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype E::value_type +PASS: gdb.cp/derivation.exp: before run: whatis E::value_type +PASS: gdb.cp/derivation.exp: before run: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype F::value_type +PASS: gdb.cp/derivation.exp: before run: whatis F::value_type +PASS: gdb.cp/derivation.exp: before run: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype A2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A2::value_type +PASS: gdb.cp/derivation.exp: before run: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D2::value_type +PASS: gdb.cp/derivation.exp: before run: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype Z::value_type +PASS: gdb.cp/derivation.exp: before run: whatis Z::value_type +PASS: gdb.cp/derivation.exp: before run: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: whatis ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: up from marker1 +PASS: gdb.cp/derivation.exp: print value of a_instance +PASS: gdb.cp/derivation.exp: ptype a_instance +PASS: gdb.cp/derivation.exp: print value of d_instance +PASS: gdb.cp/derivation.exp: ptype d_instance +PASS: gdb.cp/derivation.exp: print value of e_instance +PASS: gdb.cp/derivation.exp: ptype e_instance +PASS: gdb.cp/derivation.exp: print value of f_instance +PASS: gdb.cp/derivation.exp: ptype f_instance +PASS: gdb.cp/derivation.exp: ptype g_instance +PASS: gdb.cp/derivation.exp: print value of d_instance.a +PASS: gdb.cp/derivation.exp: print value of d_instance.aa +PASS: gdb.cp/derivation.exp: print value of d_instance.b +PASS: gdb.cp/derivation.exp: print value of d_instance.bb +PASS: gdb.cp/derivation.exp: print value of d_instance.c +PASS: gdb.cp/derivation.exp: print value of d_instance.cc +PASS: gdb.cp/derivation.exp: print value of d_instance.d +PASS: gdb.cp/derivation.exp: print value of d_instance.dd +PASS: gdb.cp/derivation.exp: print value of g_instance.a +PASS: gdb.cp/derivation.exp: print value of g_instance.b +PASS: gdb.cp/derivation.exp: print value of g_instance.c +PASS: gdb.cp/derivation.exp: print value of g_instance.afoo() +PASS: gdb.cp/derivation.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/derivation.exp: print value of g_instance.bfoo() +PASS: gdb.cp/derivation.exp: print value of g_instance.cfoo() +PASS: gdb.cp/derivation.exp: whatis c_instance.c +PASS: gdb.cp/derivation.exp: ptype c_instance.c +PASS: gdb.cp/derivation.exp: whatis g_instance.g +PASS: gdb.cp/derivation.exp: ptype g_instance.g +PASS: gdb.cp/derivation.exp: whatis a_instance.a +PASS: gdb.cp/derivation.exp: ptype a_instance.a +PASS: gdb.cp/derivation.exp: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis b_instance.b +PASS: gdb.cp/derivation.exp: ptype b_instance.b +PASS: gdb.cp/derivation.exp: whatis d_instance.d +PASS: gdb.cp/derivation.exp: ptype d_instance.d +PASS: gdb.cp/derivation.exp: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis e_instance.e +PASS: gdb.cp/derivation.exp: ptype e_instance.e +PASS: gdb.cp/derivation.exp: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis f_instance.f +PASS: gdb.cp/derivation.exp: ptype f_instance.f +PASS: gdb.cp/derivation.exp: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis z_instance.z +PASS: gdb.cp/derivation.exp: ptype z_instance.z +PASS: gdb.cp/derivation.exp: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis zz_instance.zz +PASS: gdb.cp/derivation.exp: ptype zz_instance.zz +PASS: gdb.cp/derivation.exp: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: ptype vderived +PASS: gdb.cp/derivation.exp: print vderived +PASS: gdb.cp/derivation.exp: ptype N::value_type +PASS: gdb.cp/derivation.exp: ptype N::Derived::value_type +PASS: gdb.cp/derivation.exp: ptype value_type +Running ./gdb.cp/destrprint.exp ... +PASS: gdb.cp/destrprint.exp: continue to breakpoint: Break here +PASS: gdb.cp/destrprint.exp: go up to ~Derived +PASS: gdb.cp/destrprint.exp: set print object on +PASS: gdb.cp/destrprint.exp: print *this with print object = on +PASS: gdb.cp/destrprint.exp: set print object off +PASS: gdb.cp/destrprint.exp: print *this with print object = off +Running ./gdb.cp/dispcxx.exp ... +PASS: gdb.cp/dispcxx.exp: continue to breakpoint: here +PASS: gdb.cp/dispcxx.exp: display k +Running ./gdb.cp/exception.exp ... +PASS: gdb.cp/exception.exp: catch catch (before inferior run) +PASS: gdb.cp/exception.exp: catch throw (before inferior run) +PASS: gdb.cp/exception.exp: info breakpoints (before inferior run) +PASS: gdb.cp/exception.exp: Set temporary breakpoint at main +PASS: gdb.cp/exception.exp: Run to main +PASS: gdb.cp/exception.exp: info breakpoints (after inferior run) +PASS: gdb.cp/exception.exp: break catcher +PASS: gdb.cp/exception.exp: continue to first throw +PASS: gdb.cp/exception.exp: backtrace after first throw +PASS: gdb.cp/exception.exp: continue to first catch +PASS: gdb.cp/exception.exp: backtrace after first catch +PASS: gdb.cp/exception.exp: continue to catcher for the first time +PASS: gdb.cp/exception.exp: continue to second throw +PASS: gdb.cp/exception.exp: backtrace after second throw +PASS: gdb.cp/exception.exp: continue to second catch +PASS: gdb.cp/exception.exp: backtrace after second catch +PASS: gdb.cp/exception.exp: continue to catcher for the second time +Running ./gdb.cp/expand-psymtabs-cxx.exp ... +PASS: gdb.cp/expand-psymtabs-cxx.exp: set language c++ +PASS: gdb.cp/expand-psymtabs-cxx.exp: before expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: force expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: after expand +Running ./gdb.cp/expand-sals.exp ... +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: func +PASS: gdb.cp/expand-sals.exp: up +PASS: gdb.cp/expand-sals.exp: break +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: caller +PASS: gdb.cp/expand-sals.exp: bt from A +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: next caller func +Running ./gdb.cp/extern-c.exp ... +PASS: gdb.cp/extern-c.exp: setting breakpoint at c_func +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_func +PASS: gdb.cp/extern-c.exp: initialize counter +PASS: gdb.cp/extern-c.exp: rbreak c_funcs +PASS: gdb.cp/extern-c.exp: command details for multiple breakpoints +PASS: gdb.cp/extern-c.exp: set commands on multiple breakpoints +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_1 +PASS: gdb.cp/extern-c.exp: verify counter at first breakpoint +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_2 +PASS: gdb.cp/extern-c.exp: verify counter at second breakpoint +Running ./gdb.cp/formatted-ref.exp ... +PASS: gdb.cp/formatted-ref.exp: print/x s +PASS: gdb.cp/formatted-ref.exp: print/x e +PASS: gdb.cp/formatted-ref.exp: print/x i +PASS: gdb.cp/formatted-ref.exp: print/x &s +PASS: gdb.cp/formatted-ref.exp: print/x &e +PASS: gdb.cp/formatted-ref.exp: print/x &i +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&s)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&i)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&e)) +PASS: gdb.cp/formatted-ref.exp: print s.x == 13 +Running ./gdb.cp/fpointer.exp ... +PASS: gdb.cp/fpointer.exp: p p1() +PASS: gdb.cp/fpointer.exp: p p2() +PASS: gdb.cp/fpointer.exp: p p[0]() +PASS: gdb.cp/fpointer.exp: p p[1]() +PASS: gdb.cp/fpointer.exp: p p3('a') +PASS: gdb.cp/fpointer.exp: p p4(1) +Running ./gdb.cp/gdb1355.exp ... +PASS: gdb.cp/gdb1355.exp: ptype s1 +PASS: gdb.cp/gdb1355.exp: print s1 +Running ./gdb.cp/gdb2384.exp ... +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/gdb2384.exp: print d1.meth () +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/gdb2384.exp: gdb2384 +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +PASS: gdb.cp/gdb2384.exp: print d2.meth() +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +PASS: gdb.cp/gdb2384.exp: gdb2384 (second) +Running ./gdb.cp/gdb2495.exp ... +PASS: gdb.cp/gdb2495.exp: p exceptions.no_throw_function() +PASS: gdb.cp/gdb2495.exp: p exceptions.throw_function_with_handler() +FAIL: gdb.cp/gdb2495.exp: Call a function that raises an exception without a handler. +FAIL: gdb.cp/gdb2495.exp: bt after returning from a popped frame +PASS: gdb.cp/gdb2495.exp: info breakpoints +PASS: gdb.cp/gdb2495.exp: set unwinn-on-terminating-exception off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on terminating exception flag +PASS: gdb.cp/gdb2495.exp: Call a function that raises an exception with unwinding off.. +PASS: gdb.cp/gdb2495.exp: set unwindonsignal on +PASS: gdb.cp/gdb2495.exp: Turn on unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +PASS: gdb.cp/gdb2495.exp: set unwindonsignal off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +Running ./gdb.cp/hang.exp ... +PASS: gdb.cp/hang.exp: doesn't overwrite struct type +PASS: gdb.cp/hang.exp: doesn't corrupt cv_type chain +Running ./gdb.cp/infcall-dlopen.exp ... +PASS: gdb.cp/infcall-dlopen.exp: test 0 +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 2 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 3 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 4 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 5 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 6 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 7 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 8 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 9 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 2 +Running ./gdb.cp/inherit.exp ... +PASS: gdb.cp/inherit.exp: set width 0 +PASS: gdb.cp/inherit.exp: set language c++ +PASS: gdb.cp/inherit.exp: ptype A (FIXME) +PASS: gdb.cp/inherit.exp: ptype class A (FIXME) +PASS: gdb.cp/inherit.exp: ptype g_A (FIXME) +PASS: gdb.cp/inherit.exp: ptype B +PASS: gdb.cp/inherit.exp: ptype class B +PASS: gdb.cp/inherit.exp: ptype g_B +PASS: gdb.cp/inherit.exp: ptype C +PASS: gdb.cp/inherit.exp: ptype class C +PASS: gdb.cp/inherit.exp: ptype g_C +PASS: gdb.cp/inherit.exp: ptype tagless struct +PASS: gdb.cp/inherit.exp: ptype variable of type tagless struct +PASS: gdb.cp/inherit.exp: ptype D +PASS: gdb.cp/inherit.exp: ptype class D +PASS: gdb.cp/inherit.exp: ptype g_D +PASS: gdb.cp/inherit.exp: ptype E +PASS: gdb.cp/inherit.exp: ptype class E +PASS: gdb.cp/inherit.exp: ptype g_E +PASS: gdb.cp/inherit.exp: ptype vA +PASS: gdb.cp/inherit.exp: ptype class vA +PASS: gdb.cp/inherit.exp: ptype g_vA +PASS: gdb.cp/inherit.exp: ptype vB +PASS: gdb.cp/inherit.exp: ptype class vB +PASS: gdb.cp/inherit.exp: ptype g_vB +PASS: gdb.cp/inherit.exp: ptype vC +PASS: gdb.cp/inherit.exp: ptype class vC +PASS: gdb.cp/inherit.exp: ptype g_vC +PASS: gdb.cp/inherit.exp: ptype vD +PASS: gdb.cp/inherit.exp: ptype class vD +PASS: gdb.cp/inherit.exp: ptype g_vD +PASS: gdb.cp/inherit.exp: ptype vE +PASS: gdb.cp/inherit.exp: ptype class vE +PASS: gdb.cp/inherit.exp: ptype g_vE +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_A.a +PASS: gdb.cp/inherit.exp: print g_A.x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_B.a +PASS: gdb.cp/inherit.exp: print g_B.b +PASS: gdb.cp/inherit.exp: print g_B.x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_C.a +PASS: gdb.cp/inherit.exp: print g_C.c +PASS: gdb.cp/inherit.exp: print g_C.x +PASS: gdb.cp/inherit.exp: print g_A +PASS: gdb.cp/inherit.exp: print g_B +PASS: gdb.cp/inherit.exp: print g_C +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_D.A::a +PASS: gdb.cp/inherit.exp: print g_D.C::a +PASS: gdb.cp/inherit.exp: print g_D.B::a +PASS: gdb.cp/inherit.exp: print g_D.A::x +PASS: gdb.cp/inherit.exp: print g_D.B::b +PASS: gdb.cp/inherit.exp: print g_D.B::x +PASS: gdb.cp/inherit.exp: print g_D.C::c +PASS: gdb.cp/inherit.exp: print g_D.C::x +PASS: gdb.cp/inherit.exp: print g_D.D::d +PASS: gdb.cp/inherit.exp: print g_D.D::x +PASS: gdb.cp/inherit.exp: print g_E.A::a +PASS: gdb.cp/inherit.exp: print g_E.A::x +PASS: gdb.cp/inherit.exp: print g_E.B::b +PASS: gdb.cp/inherit.exp: print g_E.B::x +PASS: gdb.cp/inherit.exp: print g_E.C::c +PASS: gdb.cp/inherit.exp: print g_E.C::x +PASS: gdb.cp/inherit.exp: print g_E.D::d +PASS: gdb.cp/inherit.exp: print g_E.D::x +PASS: gdb.cp/inherit.exp: print g_E.E::e +PASS: gdb.cp/inherit.exp: print g_E.E::x +PASS: gdb.cp/inherit.exp: ptype g_D.b +PASS: gdb.cp/inherit.exp: ptype g_D.c +PASS: gdb.cp/inherit.exp: ptype g_D.d +PASS: gdb.cp/inherit.exp: ptype g_A.A::a +PASS: gdb.cp/inherit.exp: ptype g_A.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.A::a +PASS: gdb.cp/inherit.exp: ptype g_B.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.B::b +PASS: gdb.cp/inherit.exp: ptype g_B.B::x +PASS: gdb.cp/inherit.exp: ptype g_C.A::a +PASS: gdb.cp/inherit.exp: ptype g_C.A::x +PASS: gdb.cp/inherit.exp: ptype g_C.C::c +PASS: gdb.cp/inherit.exp: ptype g_C.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.A::a +PASS: gdb.cp/inherit.exp: ptype g_D.A::x +PASS: gdb.cp/inherit.exp: ptype g_D.B::b +PASS: gdb.cp/inherit.exp: ptype g_D.B::x +PASS: gdb.cp/inherit.exp: ptype g_D.C::c +PASS: gdb.cp/inherit.exp: ptype g_D.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.D::d +PASS: gdb.cp/inherit.exp: ptype g_D.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.A::a +PASS: gdb.cp/inherit.exp: ptype g_E.A::x +PASS: gdb.cp/inherit.exp: ptype g_E.B::b +PASS: gdb.cp/inherit.exp: ptype g_E.B::x +PASS: gdb.cp/inherit.exp: ptype g_E.C::c +PASS: gdb.cp/inherit.exp: ptype g_E.C::x +PASS: gdb.cp/inherit.exp: ptype g_E.D::d +PASS: gdb.cp/inherit.exp: ptype g_E.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.E::e +PASS: gdb.cp/inherit.exp: ptype g_E.E::x +PASS: gdb.cp/inherit.exp: print g_D +PASS: gdb.cp/inherit.exp: print g_E +PASS: gdb.cp/inherit.exp: print anonymous union member +PASS: gdb.cp/inherit.exp: print variable of type anonymous union +PASS: gdb.cp/inherit.exp: print type of anonymous union +PASS: gdb.cp/inherit.exp: print g_vA.vA::va +PASS: gdb.cp/inherit.exp: print g_vA.vA::vx +PASS: gdb.cp/inherit.exp: print g_vA.va +PASS: gdb.cp/inherit.exp: print g_vA.vx +PASS: gdb.cp/inherit.exp: print g_vB.vA::va +PASS: gdb.cp/inherit.exp: print g_vB.vA::vx +PASS: gdb.cp/inherit.exp: print g_vB.vB::vb +PASS: gdb.cp/inherit.exp: print g_vB.vB::vx +PASS: gdb.cp/inherit.exp: print g_vB.va +PASS: gdb.cp/inherit.exp: print g_vB.vb +PASS: gdb.cp/inherit.exp: print g_vB.vx +PASS: gdb.cp/inherit.exp: print g_vC.vA::va +PASS: gdb.cp/inherit.exp: print g_vC.vA::vx +PASS: gdb.cp/inherit.exp: print g_vC.vC::vc +PASS: gdb.cp/inherit.exp: print g_vC.vC::vx +PASS: gdb.cp/inherit.exp: print g_vC.va +PASS: gdb.cp/inherit.exp: print g_vC.vc +PASS: gdb.cp/inherit.exp: print g_vC.vx +PASS: gdb.cp/inherit.exp: print g_vA +PASS: gdb.cp/inherit.exp: print g_vB (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vC (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vD.vA::va +PASS: gdb.cp/inherit.exp: print g_vD.vA::vx +PASS: gdb.cp/inherit.exp: print g_vD.vB::vb +PASS: gdb.cp/inherit.exp: print g_vD.vB::vx +PASS: gdb.cp/inherit.exp: print g_vD.vC::vc +PASS: gdb.cp/inherit.exp: print g_vD.vC::vx +PASS: gdb.cp/inherit.exp: print g_vD.vD::vd +PASS: gdb.cp/inherit.exp: print g_vD.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vA::va +PASS: gdb.cp/inherit.exp: print g_vE.vA::vx +PASS: gdb.cp/inherit.exp: print g_vE.vB::vb +PASS: gdb.cp/inherit.exp: print g_vE.vB::vx +PASS: gdb.cp/inherit.exp: print g_vE.vC::vc +PASS: gdb.cp/inherit.exp: print g_vE.vC::vx +PASS: gdb.cp/inherit.exp: print g_vE.vD::vd +PASS: gdb.cp/inherit.exp: print g_vE.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vE::ve +PASS: gdb.cp/inherit.exp: print g_vE.vE::vx +PASS: gdb.cp/inherit.exp: print g_vD (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vE (FIXME v3 vtbl ptr) +Running ./gdb.cp/koenig.exp ... +PASS: gdb.cp/koenig.exp: p first(c) +PASS: gdb.cp/koenig.exp: p second(0,0,c,0,0) +PASS: gdb.cp/koenig.exp: p entry (c) +PASS: gdb.cp/koenig.exp: p first(0,c) +PASS: gdb.cp/koenig.exp: p first(b.c) +PASS: gdb.cp/koenig.exp: p foo(eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo, 1) +PASS: gdb.cp/koenig.exp: p foo(fo, eo) +PASS: gdb.cp/koenig.exp: p foo(1 ,fo, eo) +PASS: gdb.cp/koenig.exp: p foo(go, fo, eo) +PASS: gdb.cp/koenig.exp: p fake(eo) +PASS: gdb.cp/koenig.exp: p foo (fake) +PASS: gdb.cp/koenig.exp: p foo(io) +PASS: gdb.cp/koenig.exp: p foo(ix) +PASS: gdb.cp/koenig.exp: p foo(ju) +PASS: gdb.cp/koenig.exp: p foo(js) +PASS: gdb.cp/koenig.exp: p foo(je) +XFAIL: gdb.cp/koenig.exp: p foo(jab) +PASS: gdb.cp/koenig.exp: p foo(jap) +PASS: gdb.cp/koenig.exp: p foo(japp) +PASS: gdb.cp/koenig.exp: p foo(jca) +PASS: gdb.cp/koenig.exp: p foo(ko,1) +PASS: gdb.cp/koenig.exp: p foo(ko,1.0f) +XFAIL: gdb.cp/koenig.exp: p bar(ko,1) +PASS: gdb.cp/koenig.exp: p foo(labo) +PASS: gdb.cp/koenig.exp: p ma.foo('a') +PASS: gdb.cp/koenig.exp: p foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::FAKE::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::fake(ma,'a') +PASS: gdb.cp/koenig.exp: p M::bar('a') +PASS: gdb.cp/koenig.exp: p M::N::bar('a') +PASS: gdb.cp/koenig.exp: p foo(ttoa, 'a') +PASS: gdb.cp/koenig.exp: p foo (p_union) +PASS: gdb.cp/koenig.exp: p q == 5 +PASS: gdb.cp/koenig.exp: p q == 5.0f +PASS: gdb.cp/koenig.exp: p q != 5 +PASS: gdb.cp/koenig.exp: p q != 5.0f +PASS: gdb.cp/koenig.exp: p q + 5.0f +PASS: gdb.cp/koenig.exp: p q + 5 +PASS: gdb.cp/koenig.exp: p ++q +PASS: gdb.cp/koenig.exp: p r.rfoo() +PASS: gdb.cp/koenig.exp: continue to breakpoint: marker1 +PASS: gdb.cp/koenig.exp: p rfoo() +PASS: gdb.cp/koenig.exp: p this->rfoo() +Running ./gdb.cp/local.exp ... +PASS: gdb.cp/local.exp: up from marker1 +PASS: gdb.cp/local.exp: ptype l +PASS: gdb.cp/local.exp: ptype Local +PASS: gdb.cp/local.exp: break marker2 +PASS: gdb.cp/local.exp: continuing to marker2 +PASS: gdb.cp/local.exp: up from marker2 +PASS: gdb.cp/local.exp: Local out of scope +PASS: gdb.cp/local.exp: ptype InnerLocal (pattern 1) +PASS: gdb.cp/local.exp: ptype NestedInnerLocal +KFAIL: gdb.cp/local.exp: ptype InnerLocal::NestedInnerLocal (PRMS: gdb/482) +Running ./gdb.cp/maint.exp ... +PASS: gdb.cp/maint.exp: help maintenance cplus +PASS: gdb.cp/maint.exp: help maint cp +PASS: gdb.cp/maint.exp: maint cp +PASS: gdb.cp/maint.exp: help maint cp first_component +PASS: gdb.cp/maint.exp: help maint cp namespace +PASS: gdb.cp/maint.exp: set complaints 1000 +PASS: gdb.cp/maint.exp: maint cp first_component foo +PASS: gdb.cp/maint.exp: maint cp first_component operator<< +PASS: gdb.cp/maint.exp: maint cp first_component operator>> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator() +PASS: gdb.cp/maint.exp: maint cp first_component operator> +PASS: gdb.cp/maint.exp: maint cp first_component operator< +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component foo() +PASS: gdb.cp/maint.exp: maint cp first_component foo(int) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y, A::B) +PASS: gdb.cp/maint.exp: maint cp first_component foo(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >) +PASS: gdb.cp/maint.exp: maint cp first_component operator>(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component int operator<< <char>() +PASS: gdb.cp/maint.exp: maint cp first_component T<Cooperator> +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&(operator<<(C, C))>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar::baz +PASS: gdb.cp/maint.exp: maint cp first_component C<A>::bar +PASS: gdb.cp/maint.exp: maint cp first_component C<std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > >::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo< +PASS: gdb.cp/maint.exp: maint cp first_component foo( +PASS: gdb.cp/maint.exp: maint cp first_component bool operator<<char> +PASS: gdb.cp/maint.exp: maint cp namespace +Running ./gdb.cp/mb-ctor.exp ... +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at ctor +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at dtor +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v1 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v2 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v1 +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v2 +PASS: gdb.cp/mb-ctor.exp: run to exit +Running ./gdb.cp/mb-inline.exp ... +PASS: gdb.cp/mb-inline.exp: set breakpoint +PASS: gdb.cp/mb-inline.exp: info break +PASS: gdb.cp/mb-inline.exp: run to breakpoint +PASS: gdb.cp/mb-inline.exp: run to breakpoint 2 +PASS: gdb.cp/mb-inline.exp: disabling location: disable +PASS: gdb.cp/mb-inline.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-inline.exp: disabled breakpoint 1.2 +PASS: gdb.cp/mb-inline.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 afn +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 bfn +Running ./gdb.cp/mb-templates.exp ... +PASS: gdb.cp/mb-templates.exp: initial condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: kill +PASS: gdb.cp/mb-templates.exp: separate condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: set condition +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: disabling location: disable +PASS: gdb.cp/mb-templates.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-templates.exp: disabling location: enable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: disable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: set breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <int> +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <double> +Running ./gdb.cp/m-data.exp ... +PASS: gdb.cp/m-data.exp: continue to breakpoint: end of first constructors +PASS: gdb.cp/m-data.exp: simple object, const bool +PASS: gdb.cp/m-data.exp: simple object, const int +PASS: gdb.cp/m-data.exp: simple object, long +PASS: gdb.cp/m-data.exp: simple object, enum +PASS: gdb.cp/m-data.exp: derived template object, base const bool +PASS: gdb.cp/m-data.exp: derived template object, base const int +PASS: gdb.cp/m-data.exp: derived template object, base long +PASS: gdb.cp/m-data.exp: derived template object, base enum +PASS: gdb.cp/m-data.exp: derived template object, derived enum +PASS: gdb.cp/m-data.exp: template object, const bool +PASS: gdb.cp/m-data.exp: template object, const int +PASS: gdb.cp/m-data.exp: template object, long +PASS: gdb.cp/m-data.exp: template object, base enum +PASS: gdb.cp/m-data.exp: template object, derived enum +PASS: gdb.cp/m-data.exp: continue to breakpoint: continue to shadow breakpoint +PASS: gdb.cp/m-data.exp: shadowing member +PASS: gdb.cp/m-data.exp: shadowed global variable +Running ./gdb.cp/member-name.exp ... +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to first breakpoint +PASS: gdb.cp/member-name.exp: print C::x from first breakpoint +PASS: gdb.cp/member-name.exp: print B::b from first breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from first breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to second breakpoint +PASS: gdb.cp/member-name.exp: print C::x from second breakpoint +PASS: gdb.cp/member-name.exp: print B::b from second breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from second breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to third breakpoint +PASS: gdb.cp/member-name.exp: print Templ::y from third breakpoint +Running ./gdb.cp/member-ptr.exp ... +PASS: gdb.cp/member-ptr.exp: continue to breakpoint: continue to pmi = NULL +PASS: gdb.cp/member-ptr.exp: ptype pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::jj +PASS: gdb.cp/member-ptr.exp: print pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (again) +PASS: gdb.cp/member-ptr.exp: print a.*pmi = 33 +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (33) +PASS: gdb.cp/member-ptr.exp: print a (j = 33) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi = 44 +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (44) +PASS: gdb.cp/member-ptr.exp: print a (j = 44) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmi +PASS: gdb.cp/member-ptr.exp: print *pmi +PASS: gdb.cp/member-ptr.exp: ptype *pmi +PASS: gdb.cp/member-ptr.exp: print (int) pmi +PASS: gdb.cp/member-ptr.exp: print ((int) pmi) == ((char *) &a.j - (char *) &a) +PASS: gdb.cp/member-ptr.exp: ptype diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: ptype diamond.*diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pfunc_ptr (20) +PASS: gdb.cp/member-ptr.exp: print (diamond.*diamond_pfunc_ptr) (20) +PASS: gdb.cp/member-ptr.exp: print diamond.func_ptr (20) +PASS: gdb.cp/member-ptr.exp: ptype pmf +PASS: gdb.cp/member-ptr.exp: print pmf +PASS: gdb.cp/member-ptr.exp: ptype pmf_p +PASS: gdb.cp/member-ptr.exp: gdb/NNNN +PASS: gdb.cp/member-ptr.exp: print a.*pmf +PASS: gdb.cp/member-ptr.exp: print a_p->*pmf +PASS: gdb.cp/member-ptr.exp: set var pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print *pmf +PASS: gdb.cp/member-ptr.exp: ptype *pmf +PASS: gdb.cp/member-ptr.exp: print (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmf +PASS: gdb.cp/member-ptr.exp: ptype (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: print diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*left_pmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_pmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_pmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_pmf) () +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_vpmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_base_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_vpmf) () +PASS: gdb.cp/member-ptr.exp: print left_vpmf +PASS: gdb.cp/member-ptr.exp: print right_vpmf +PASS: gdb.cp/member-ptr.exp: print base_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf () +PASS: gdb.cp/member-ptr.exp: print null_pmi +PASS: gdb.cp/member-ptr.exp: print null_pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print null_pmi = 0 +PASS: gdb.cp/member-ptr.exp: print null_pmf +PASS: gdb.cp/member-ptr.exp: print null_pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print null_pmf = 0 +Running ./gdb.cp/method2.exp ... +PASS: gdb.cp/method2.exp: set multiple-symbols ask +PASS: gdb.cp/method2.exp: setting language c +PASS: gdb.cp/method2.exp: breaking in method (c) +PASS: gdb.cp/method2.exp: setting language c++ +PASS: gdb.cp/method2.exp: breaking in method (c++) +PASS: gdb.cp/method2.exp: continue until exit at continue to end +Running ./gdb.cp/method.exp ... +PASS: gdb.cp/method.exp: break A::foo +PASS: gdb.cp/method.exp: continue to A::foo +PASS: gdb.cp/method.exp: print x in A::foo +PASS: gdb.cp/method.exp: print this in A::foo +PASS: gdb.cp/method.exp: break A::bar +PASS: gdb.cp/method.exp: continue to A::bar +PASS: gdb.cp/method.exp: print x in A::bar +PASS: gdb.cp/method.exp: print this in A::bar +PASS: gdb.cp/method.exp: break 21 +PASS: gdb.cp/method.exp: continue to 21 +PASS: gdb.cp/method.exp: print data_ in funk::getFunky +PASS: gdb.cp/method.exp: print this in funk::getFunky +PASS: gdb.cp/method.exp: print res in funk::getFunky +PASS: gdb.cp/method.exp: ptype A +PASS: gdb.cp/method.exp: finish program +Running ./gdb.cp/meth-typedefs.exp ... +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: break test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::c::d::bar&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::c::d::bar&)' +Running ./gdb.cp/minsym-fallback.exp ... +PASS: gdb.cp/minsym-fallback.exp: set breakpoint pending off +PASS: gdb.cp/minsym-fallback.exp: break C::f() +PASS: gdb.cp/minsym-fallback.exp: break C::operator()() +Running ./gdb.cp/misc.exp ... +PASS: gdb.cp/misc.exp: deduced language is C++, before full symbols +PASS: gdb.cp/misc.exp: deduced language is C++, after full symbols +PASS: gdb.cp/misc.exp: print s.a for foo struct (known gcc 2.7.2 and earlier bug) +PASS: gdb.cp/misc.exp: print as bool (setup) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 1) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 2) +PASS: gdb.cp/misc.exp: print a bool var +PASS: gdb.cp/misc.exp: set a bool var (setup) +PASS: gdb.cp/misc.exp: set a bool var (print v_bool) +PASS: gdb.cp/misc.exp: print a bool array +PASS: gdb.cp/misc.exp: set a bool array elem (setup) +PASS: gdb.cp/misc.exp: set a bool array elem (print v_bool_array) +PASS: gdb.cp/misc.exp: print true +PASS: gdb.cp/misc.exp: print false +PASS: gdb.cp/misc.exp: 1 + true +PASS: gdb.cp/misc.exp: 3 + false +PASS: gdb.cp/misc.exp: 1 < 2 < 3 +PASS: gdb.cp/misc.exp: 2 < 1 > 4 +PASS: gdb.cp/misc.exp: (bool)43 +PASS: gdb.cp/misc.exp: (bool)0 +PASS: gdb.cp/misc.exp: (bool)17.93 +PASS: gdb.cp/misc.exp: (bool)0.0 +PASS: gdb.cp/misc.exp: (int)true +PASS: gdb.cp/misc.exp: (int)false +Running ./gdb.cp/m-static.exp ... +PASS: gdb.cp/m-static.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/m-static.exp: simple object, static const int, accessing via 'class::method::variable +PASS: gdb.cp/m-static.exp: simple object, static const bool +PASS: gdb.cp/m-static.exp: simple object, static const int +PASS: gdb.cp/m-static.exp: simple object, static long +PASS: gdb.cp/m-static.exp: simple object, static enum +FAIL: gdb.cp/m-static.exp: simple object instance, print quoted destructor +FAIL: gdb.cp/m-static.exp: simple object class, ptype quoted destructor +PASS: gdb.cp/m-static.exp: derived template object, base static const bool +PASS: gdb.cp/m-static.exp: derived template object, base static const int +PASS: gdb.cp/m-static.exp: derived template object, base static long +PASS: gdb.cp/m-static.exp: derived template object, base static enum +PASS: gdb.cp/m-static.exp: derived template object, static enum +PASS: gdb.cp/m-static.exp: template object, static const bool +PASS: gdb.cp/m-static.exp: template object, static const int +PASS: gdb.cp/m-static.exp: template object, static long +PASS: gdb.cp/m-static.exp: template object, static enum +PASS: gdb.cp/m-static.exp: template object, static derived enum +PASS: gdb.cp/m-static.exp: static const int initialized elsewhere +PASS: gdb.cp/m-static.exp: static const int initialized nowhere +PASS: gdb.cp/m-static.exp: static const int initialized in class definition +PASS: gdb.cp/m-static.exp: static const float initialized in class definition +PASS: gdb.cp/m-static.exp: info variable everywhere +PASS: gdb.cp/m-static.exp: step +PASS: gdb.cp/m-static.exp: print svar +Running ./gdb.cp/namespace-enum.exp ... +PASS: gdb.cp/namespace-enum.exp: print foo::B::B_B +PASS: gdb.cp/namespace-enum.exp: print foo::B_B +PASS: gdb.cp/namespace-enum.exp: print A_A +Running ./gdb.cp/namespace.exp ... +PASS: gdb.cp/namespace.exp: show lang +PASS: gdb.cp/namespace.exp: up from marker1 +PASS: gdb.cp/namespace.exp: print 'AAA::c' +PASS: gdb.cp/namespace.exp: print AAA::c +PASS: gdb.cp/namespace.exp: print ina +PASS: gdb.cp/namespace.exp: ptype ina +PASS: gdb.cp/namespace.exp: info func xyzq +PASS: gdb.cp/namespace.exp: print 'AAA::xyzq'('x') +PASS: gdb.cp/namespace.exp: print AAA::xyzq('x') +PASS: gdb.cp/namespace.exp: break AAA::xyzq +PASS: gdb.cp/namespace.exp: break ::ensureOtherRefs +PASS: gdb.cp/namespace.exp: print 'BBB::CCC::xyzq'('x') +PASS: gdb.cp/namespace.exp: print BBB::CCC::xyzq('x') +PASS: gdb.cp/namespace.exp: break BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: break ::BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: print 'BBB::Class::xyzq' +PASS: gdb.cp/namespace.exp: print BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: break BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: whatis ::C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: print C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print c +PASS: gdb.cp/namespace.exp: print cc +PASS: gdb.cp/namespace.exp: print 'C::cc' +PASS: gdb.cp/namespace.exp: print C::cc +PASS: gdb.cp/namespace.exp: print cd +PASS: gdb.cp/namespace.exp: print C::D::cd +PASS: gdb.cp/namespace.exp: print 'E::cde' +PASS: gdb.cp/namespace.exp: print E::cde +PASS: gdb.cp/namespace.exp: print shadow +PASS: gdb.cp/namespace.exp: print E::ce +PASS: gdb.cp/namespace.exp: ptype C +PASS: gdb.cp/namespace.exp: ptype E +PASS: gdb.cp/namespace.exp: ptype CClass +PASS: gdb.cp/namespace.exp: ptype CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::CClass +PASS: gdb.cp/namespace.exp: ptype C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::NestedClass +PASS: gdb.cp/namespace.exp: print cOtherFile +PASS: gdb.cp/namespace.exp: ptype OtherFileClass +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: print cX +PASS: gdb.cp/namespace.exp: print 'F::cXf' +PASS: gdb.cp/namespace.exp: print F::cXf +PASS: gdb.cp/namespace.exp: print F::cXfX +PASS: gdb.cp/namespace.exp: print X +PASS: gdb.cp/namespace.exp: print 'G::Xg' +PASS: gdb.cp/namespace.exp: print G::Xg +PASS: gdb.cp/namespace.exp: print G::XgX +PASS: gdb.cp/namespace.exp: print cXOtherFile +PASS: gdb.cp/namespace.exp: print XOtherFile +PASS: gdb.cp/namespace.exp: print AAA::ALPHA +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass * +Running ./gdb.cp/namespace-nested-import.exp ... +PASS: gdb.cp/namespace-nested-import.exp: print C::x +Running ./gdb.cp/nextoverthrow.exp ... +UNSUPPORTED: gdb.cp/nextoverthrow.exp: nextoverthrow.exp could not find _Unwind_DebugHook +Running ./gdb.cp/no-dmgl-verbose.exp ... +PASS: gdb.cp/no-dmgl-verbose.exp: set breakpoint pending off +PASS: gdb.cp/no-dmgl-verbose.exp: DMGL_VERBOSE-demangled f(std::string) is not defined +Running ./gdb.cp/noparam.exp ... +PASS: gdb.cp/noparam.exp: p C::m (int) +Running ./gdb.cp/nsdecl.exp ... +PASS: gdb.cp/nsdecl.exp: print fakex +Running ./gdb.cp/nsimport.exp ... +PASS: gdb.cp/nsimport.exp: print x +PASS: gdb.cp/nsimport.exp: print xx +PASS: gdb.cp/nsimport.exp: print xxx +Running ./gdb.cp/nsnested.exp ... +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::first +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: print C::D::ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::D::second +PASS: gdb.cp/nsnested.exp: print ab +Running ./gdb.cp/nsnoimports.exp ... +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::first +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print C::abc +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::C::second +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +Running ./gdb.cp/nsrecurs.exp ... +PASS: gdb.cp/nsrecurs.exp: print ax +PASS: gdb.cp/nsrecurs.exp: print dx +PASS: gdb.cp/nsrecurs.exp: print xx +KFAIL: gdb.cp/nsrecurs.exp: ptype G::GF (PRMS: gdb/10541) +KFAIL: gdb.cp/nsrecurs.exp: print G::GF::FE::ex (PRMS: gdb/10541) +Running ./gdb.cp/nsstress.exp ... +PASS: gdb.cp/nsstress.exp: print y +Running ./gdb.cp/nsusing.exp ... +PASS: gdb.cp/nsusing.exp: print _a +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker3 +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker1 stop +PASS: gdb.cp/nsusing.exp: print _a in a nested scope +PASS: gdb.cp/nsusing.exp: print cc +PASS: gdb.cp/nsusing.exp: print B::_a +PASS: gdb.cp/nsusing.exp: print _a in namespace alias scope +PASS: gdb.cp/nsusing.exp: print x in namespace alias scope +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: print dx +PASS: gdb.cp/nsusing.exp: print efx +PASS: gdb.cp/nsusing.exp: print ghx +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: K::marker9 +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker10 stop +PASS: gdb.cp/nsusing.exp: print x (from M::x) +Running ./gdb.cp/operator.exp ... +PASS: gdb.cp/operator.exp: global operator +PASS: gdb.cp/operator.exp: global operator overload +PASS: gdb.cp/operator.exp: ADL operator +PASS: gdb.cp/operator.exp: ADL operator overload +PASS: gdb.cp/operator.exp: Fully qualified explicit operator call +PASS: gdb.cp/operator.exp: anonymous namespace operator +PASS: gdb.cp/operator.exp: anonymous namespace operator overload +PASS: gdb.cp/operator.exp: anonymous namespace operator overload float +PASS: gdb.cp/operator.exp: imported operator +PASS: gdb.cp/operator.exp: imported operator overload +PASS: gdb.cp/operator.exp: imported operator overload float +PASS: gdb.cp/operator.exp: member operator +PASS: gdb.cp/operator.exp: member operator overload +PASS: gdb.cp/operator.exp: namespace alias +PASS: gdb.cp/operator.exp: imported declaration +PASS: gdb.cp/operator.exp: p l == 1 +PASS: gdb.cp/operator.exp: p x[0] +Running ./gdb.cp/oranking.exp ... +PASS: gdb.cp/oranking.exp: continue to breakpoint: end of main +KFAIL: gdb.cp/oranking.exp: p foo0(b) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test1() +PASS: gdb.cp/oranking.exp: p foo1(b) +PASS: gdb.cp/oranking.exp: p test2() +KFAIL: gdb.cp/oranking.exp: p foo2(b) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test3() +PASS: gdb.cp/oranking.exp: p foo3(1.0f) +PASS: gdb.cp/oranking.exp: p test4() +KFAIL: gdb.cp/oranking.exp: p foo4(&a) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test5() +PASS: gdb.cp/oranking.exp: p foo5(c) +PASS: gdb.cp/oranking.exp: p test6() +PASS: gdb.cp/oranking.exp: p foo6(bp) +PASS: gdb.cp/oranking.exp: p test7() +PASS: gdb.cp/oranking.exp: p foo7(cp) +PASS: gdb.cp/oranking.exp: p test8() +PASS: gdb.cp/oranking.exp: p foo8(co) +PASS: gdb.cp/oranking.exp: p test9() +PASS: gdb.cp/oranking.exp: p foo9(co) +PASS: gdb.cp/oranking.exp: p test10() +KFAIL: gdb.cp/oranking.exp: p foo10(amp) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test101() +KFAIL: gdb.cp/oranking.exp: p foo101("abc") (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test11() +KFAIL: gdb.cp/oranking.exp: p foo11(d) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test12() +PASS: gdb.cp/oranking.exp: p foo12(1) +PASS: gdb.cp/oranking.exp: p test13() +KFAIL: gdb.cp/oranking.exp: p foo13(c) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test14() +KFAIL: gdb.cp/oranking.exp: p foo14(e) (PRMS: gdb/12096) +Running ./gdb.cp/overload-const.exp ... +PASS: gdb.cp/overload-const.exp: set language c++ +PASS: gdb.cp/overload-const.exp: setting breakpoint at myclass::func +Running ./gdb.cp/overload.exp ... +PASS: gdb.cp/overload.exp: up from marker1 +PASS: gdb.cp/overload.exp: print foo_instance1 +PASS: gdb.cp/overload.exp: ptype foo_instance1 (shorter match) +PASS: gdb.cp/overload.exp: print foo_instance2 +PASS: gdb.cp/overload.exp: print foo_instance3 +PASS: gdb.cp/overload.exp: print call overloaded func 1 arg +PASS: gdb.cp/overload.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/overload.exp: print call overloaded func 2 args +PASS: gdb.cp/overload.exp: print call overloaded func 3 args +PASS: gdb.cp/overload.exp: print call overloaded func 4 args +PASS: gdb.cp/overload.exp: print call overloaded func 5 args +PASS: gdb.cp/overload.exp: print call overloaded func 6 args +PASS: gdb.cp/overload.exp: print call overloaded func 7 args +PASS: gdb.cp/overload.exp: print call overloaded func 8 args +PASS: gdb.cp/overload.exp: print call overloaded func 9 args +PASS: gdb.cp/overload.exp: print call overloaded func 10 args +PASS: gdb.cp/overload.exp: print call overloaded func 11 args +PASS: gdb.cp/overload.exp: print call overloaded func void arg +PASS: gdb.cp/overload.exp: print call overloaded func char arg +PASS: gdb.cp/overload.exp: print call overloaded func signed char arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned char arg +PASS: gdb.cp/overload.exp: print call overloaded func short arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned short arg +PASS: gdb.cp/overload.exp: print call overloaded func int arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned int arg +PASS: gdb.cp/overload.exp: print call overloaded func long arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned long arg +PASS: gdb.cp/overload.exp: print call overloaded func float arg +PASS: gdb.cp/overload.exp: print call overloaded func double arg +PASS: gdb.cp/overload.exp: print call overloaded func int\* arg +PASS: gdb.cp/overload.exp: print call overloaded func char\* arg +PASS: gdb.cp/overload.exp: print bar(a) +PASS: gdb.cp/overload.exp: print bar(b) +PASS: gdb.cp/overload.exp: print bar(c) +PASS: gdb.cp/overload.exp: print bar(d) +PASS: gdb.cp/overload.exp: list overloaded function with no args +PASS: gdb.cp/overload.exp: list overloaded function with int arg +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args - quotes around argument +PASS: gdb.cp/overload.exp: list overload.cc:intToChar +PASS: gdb.cp/overload.exp: list overload.cc:intToChar(char) +PASS: gdb.cp/overload.exp: list overload.cc:'intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc:intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc':intToChar(char) +PASS: gdb.cp/overload.exp: list 'overload.cc':'intToChar(char)' +PASS: gdb.cp/overload.exp: list overload.cc:foo::overloadfnarg(int) +PASS: gdb.cp/overload.exp: list overload.cc:'foo::overloadfnarg(int)' +PASS: gdb.cp/overload.exp: print overloadNamespace(1) +PASS: gdb.cp/overload.exp: print overloadNamespace('a') +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) +PASS: gdb.cp/overload.exp: print K::staticoverload () +PASS: gdb.cp/overload.exp: print K::staticoverload (2) +PASS: gdb.cp/overload.exp: print K::staticoverload (2, 3) +PASS: gdb.cp/overload.exp: print N::nsoverload () +PASS: gdb.cp/overload.exp: print N::nsoverload (2) +PASS: gdb.cp/overload.exp: print N::nsoverload (2, 3) +PASS: gdb.cp/overload.exp: print overloadNamespace(1) in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace('a') in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) in XXX +PASS: gdb.cp/overload.exp: print intToChar(1) +PASS: gdb.cp/overload.exp: print foo::overload1arg +PASS: gdb.cp/overload.exp: print foo::overload1arg(char***) +PASS: gdb.cp/overload.exp: print foo::overload1arg(void) +PASS: gdb.cp/overload.exp: print foo::overload1arg(char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(signed char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(float) +PASS: gdb.cp/overload.exp: print foo::overload1arg(double) +Running ./gdb.cp/ovldbreak.exp ... +PASS: gdb.cp/ovldbreak.exp: detect void +PASS: gdb.cp/ovldbreak.exp: detect char +PASS: gdb.cp/ovldbreak.exp: detect signed_char +PASS: gdb.cp/ovldbreak.exp: detect unsigned_char +PASS: gdb.cp/ovldbreak.exp: detect short_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: detect int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_int +PASS: gdb.cp/ovldbreak.exp: detect long_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: detect float +PASS: gdb.cp/ovldbreak.exp: detect double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols ask +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 2 +PASS: gdb.cp/ovldbreak.exp: set bp 2 on foo::overload1arg 2 line 107 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 3 +PASS: gdb.cp/ovldbreak.exp: set bp 3 on foo::overload1arg 3 line 110 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 4 +PASS: gdb.cp/ovldbreak.exp: set bp 4 on foo::overload1arg 4 line 140 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 5 +PASS: gdb.cp/ovldbreak.exp: set bp 5 on foo::overload1arg 5 line 137 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 6 +PASS: gdb.cp/ovldbreak.exp: set bp 6 on foo::overload1arg 6 line 125 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 7 +PASS: gdb.cp/ovldbreak.exp: set bp 7 on foo::overload1arg 7 line 131 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 8 +PASS: gdb.cp/ovldbreak.exp: set bp 8 on foo::overload1arg 8 line 119 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 9 +PASS: gdb.cp/ovldbreak.exp: set bp 9 on foo::overload1arg 9 line 113 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 10 +PASS: gdb.cp/ovldbreak.exp: set bp 10 on foo::overload1arg 10 line 116 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 11 +PASS: gdb.cp/ovldbreak.exp: set bp 11 on foo::overload1arg 11 line 128 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 12 +PASS: gdb.cp/ovldbreak.exp: set bp 12 on foo::overload1arg 12 line 134 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 13 +PASS: gdb.cp/ovldbreak.exp: set bp 13 on foo::overload1arg 13 line 122 +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting one-by-one) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice cancel +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg canceled +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after cancel) +PASS: gdb.cp/ovldbreak.exp: delete all breakpoints +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after delete) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice all +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg all +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting on all) +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : void +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : signed_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : float +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols cancel +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols all +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +PASS: gdb.cp/ovldbreak.exp: continue until exit at finish program +Running ./gdb.cp/ovsrch.exp ... +PASS: gdb.cp/ovsrch.exp: break A::stop_here +PASS: gdb.cp/ovsrch.exp: break 'A::stop_here' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::hibob if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::stop_here_too +PASS: gdb.cp/ovsrch.exp: break 'A::B::stop_here_too' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here_too +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::hibob if (a_param == 3) +Running ./gdb.cp/paren-type.exp ... +PASS: gdb.cp/paren-type.exp: set breakpoint pending off +PASS: gdb.cp/paren-type.exp: break C::f(long) +PASS: gdb.cp/paren-type.exp: break C::f(short) +Running ./gdb.cp/parse-lang.exp ... +PASS: gdb.cp/parse-lang.exp: breakpoint hit +Running ./gdb.cp/pass-by-ref.exp ... +PASS: gdb.cp/pass-by-ref.exp: call function in obj +PASS: gdb.cp/pass-by-ref.exp: call function in derived +PASS: gdb.cp/pass-by-ref.exp: call function in container +Running ./gdb.cp/pr-1023.exp ... +PASS: gdb.cp/pr-1023.exp: break myClass::performBlocking +PASS: gdb.cp/pr-1023.exp: break myClass::performUnblocking +Running ./gdb.cp/pr10687.exp ... +PASS: gdb.cp/pr10687.exp: continue to breakpoint: marker +PASS: gdb.cp/pr10687.exp: p a +Running ./gdb.cp/pr10728.exp ... +PASS: gdb.cp/pr10728.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/pr10728.exp: print x->y2 - x->y1 +Running ./gdb.cp/pr12028.exp ... +PASS: gdb.cp/pr12028.exp: p D::foo(b) +Running ./gdb.cp/pr-1210.exp ... +PASS: gdb.cp/pr-1210.exp: step past initialization +PASS: gdb.cp/pr-1210.exp: print *obj +PASS: gdb.cp/pr-1210.exp: print obj->myB +Running ./gdb.cp/pr-574.exp ... +PASS: gdb.cp/pr-574.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/pr-574.exp: PR gdb/574 +Running ./gdb.cp/pr9067.exp ... +PASS: gdb.cp/pr9067.exp: print b +Running ./gdb.cp/pr9167.exp ... +PASS: gdb.cp/pr9167.exp: continue to breakpoint: marker +PASS: gdb.cp/pr9167.exp: p b +Running ./gdb.cp/pr9631.exp ... +PASS: gdb.cp/pr9631.exp: continue to breakpoint: after bar tender is initialized +PASS: gdb.cp/pr9631.exp: print tender +Running ./gdb.cp/printmethod.exp ... +PASS: gdb.cp/printmethod.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/printmethod.exp: print virtual method. +PASS: gdb.cp/printmethod.exp: print nonvirtual method. +Running ./gdb.cp/psmang.exp ... +PASS: gdb.cp/psmang.exp: break s::method1 +PASS: gdb.cp/psmang.exp: break s::method2 +Running ./gdb.cp/psymtab-parameter.exp ... +PASS: gdb.cp/psymtab-parameter.exp: set language c++ +PASS: gdb.cp/psymtab-parameter.exp: maintenance info symtabs +PASS: gdb.cp/psymtab-parameter.exp: complete p 'func<short>( +Running ./gdb.cp/ptype-cv-cp.exp ... +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_const_my_int +Running ./gdb.cp/ptype-flags.exp ... +PASS: gdb.cp/ptype-flags.exp: basic test +PASS: gdb.cp/ptype-flags.exp: no methods +PASS: gdb.cp/ptype-flags.exp: no typedefs +PASS: gdb.cp/ptype-flags.exp: no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: raw +PASS: gdb.cp/ptype-flags.exp: raw no methods +PASS: gdb.cp/ptype-flags.exp: raw no typedefs +PASS: gdb.cp/ptype-flags.exp: raw no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: set print type methods off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, default methods off +PASS: gdb.cp/ptype-flags.exp: no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: set print type typedefs off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: typedefs, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods typedefs, default methods+typedefs off +Running ./gdb.cp/punctuator.exp ... +PASS: gdb.cp/punctuator.exp: set lang c++ +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitand 0xaaaa) == (0x5a5a & 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitor 0xaaaa) == (0x5a5a | 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a xor 0xaaaa) == (0x5a5a ^ 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a and 0xaaaa) == (0x5a5a && 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a or 0xaaaa) == (0x5a5a || 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (not not 0xaaaa) == (!!0xaaaa) +PASS: gdb.cp/punctuator.exp: print (compl 0xaaaa) == (~0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 1 +PASS: gdb.cp/punctuator.exp: set $v 1 +PASS: gdb.cp/punctuator.exp: print ($u not_eq 0xaaaa) == ($v != 0xaaaa) +PASS: gdb.cp/punctuator.exp: print ($u and_eq 0xaaaa) == ($v &= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 2 +PASS: gdb.cp/punctuator.exp: set $v 2 +PASS: gdb.cp/punctuator.exp: print ($u or_eq 0xaaaa) == ($v |= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 3 +PASS: gdb.cp/punctuator.exp: set $v 3 +PASS: gdb.cp/punctuator.exp: print ($u xor_eq 0xaaaa) == ($v ^= 0xaaaa) +Running ./gdb.cp/readnow-language.exp ... +PASS: gdb.cp/readnow-language.exp: show language +Running ./gdb.cp/ref-params.exp ... +PASS: gdb.cp/ref-params.exp: print value of a Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f2 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of f2 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of f1 on Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of Parent& in f1 +PASS: gdb.cp/ref-params.exp: print f1(MQ) +PASS: gdb.cp/ref-params.exp: print mf1(MQ) +PASS: gdb.cp/ref-params.exp: print mf2(MQ) +PASS: gdb.cp/ref-params.exp: print f1(MQR) +PASS: gdb.cp/ref-params.exp: print mf1(MQR) +PASS: gdb.cp/ref-params.exp: print mf2(MQR) +Running ./gdb.cp/ref-types.exp ... +PASS: gdb.cp/ref-types.exp: up from marker1 1 +PASS: gdb.cp/ref-types.exp: print value of s +PASS: gdb.cp/ref-types.exp: ptype s +PASS: gdb.cp/ref-types.exp: print value of ps +PASS: gdb.cp/ref-types.exp: ptype ps +PASS: gdb.cp/ref-types.exp: print value of as[0] +PASS: gdb.cp/ref-types.exp: ptype as +PASS: gdb.cp/ref-types.exp: print value of as[1] +PASS: gdb.cp/ref-types.exp: print value of as[2] +PASS: gdb.cp/ref-types.exp: print value of as[3] +PASS: gdb.cp/ref-types.exp: print value of rs +PASS: gdb.cp/ref-types.exp: ptype rs +PASS: gdb.cp/ref-types.exp: print value of *rps +PASS: gdb.cp/ref-types.exp: examine value at rps +PASS: gdb.cp/ref-types.exp: ptype rps +PASS: gdb.cp/ref-types.exp: print value of ras[0] +PASS: gdb.cp/ref-types.exp: ptype ras +PASS: gdb.cp/ref-types.exp: print value of ras[1] +PASS: gdb.cp/ref-types.exp: print value of ras[2] +PASS: gdb.cp/ref-types.exp: print value of ras[3] +PASS: gdb.cp/ref-types.exp: up from f +PASS: gdb.cp/ref-types.exp: print value of C +PASS: gdb.cp/ref-types.exp: ptype C +PASS: gdb.cp/ref-types.exp: print value of UC +PASS: gdb.cp/ref-types.exp: ptype UC +PASS: gdb.cp/ref-types.exp: print value of S +PASS: gdb.cp/ref-types.exp: ptype S +PASS: gdb.cp/ref-types.exp: print value of US +PASS: gdb.cp/ref-types.exp: ptype US +PASS: gdb.cp/ref-types.exp: print value of I +PASS: gdb.cp/ref-types.exp: ptype I +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: ptype UI +PASS: gdb.cp/ref-types.exp: print value of L +PASS: gdb.cp/ref-types.exp: ptype L +PASS: gdb.cp/ref-types.exp: print value of UL +PASS: gdb.cp/ref-types.exp: ptype UL +PASS: gdb.cp/ref-types.exp: print value of F +PASS: gdb.cp/ref-types.exp: ptype F +PASS: gdb.cp/ref-types.exp: print value of D +PASS: gdb.cp/ref-types.exp: ptype D +PASS: gdb.cp/ref-types.exp: ptype rC +PASS: gdb.cp/ref-types.exp: ptype rUC +PASS: gdb.cp/ref-types.exp: ptype rS +PASS: gdb.cp/ref-types.exp: ptype rUS +PASS: gdb.cp/ref-types.exp: ptype rI +PASS: gdb.cp/ref-types.exp: ptype rUI +PASS: gdb.cp/ref-types.exp: ptype rL +PASS: gdb.cp/ref-types.exp: ptype rUL +PASS: gdb.cp/ref-types.exp: ptype rF +PASS: gdb.cp/ref-types.exp: ptype rD +PASS: gdb.cp/ref-types.exp: print value of rC +PASS: gdb.cp/ref-types.exp: print value of rUC +PASS: gdb.cp/ref-types.exp: print value of rS +PASS: gdb.cp/ref-types.exp: print value of rUS +PASS: gdb.cp/ref-types.exp: print value of rI +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: print value of rL +PASS: gdb.cp/ref-types.exp: print value of rUL +PASS: gdb.cp/ref-types.exp: print value of rF +PASS: gdb.cp/ref-types.exp: print value of rD +Running ./gdb.cp/re-set-overloaded.exp ... +PASS: gdb.cp/re-set-overloaded.exp: set breakpoint pending yes +PASS: gdb.cp/re-set-overloaded.exp: break C::C +PASS: gdb.cp/re-set-overloaded.exp: set variable $brk = $bpnum +PASS: gdb.cp/re-set-overloaded.exp: start +PASS: gdb.cp/re-set-overloaded.exp: breakpoint resolved +Running ./gdb.cp/rtti.exp ... +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in main +PASS: gdb.cp/rtti.exp: print *e1 +PASS: gdb.cp/rtti.exp: print *e2 +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func +PASS: gdb.cp/rtti.exp: print *obj +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func3 +PASS: gdb.cp/rtti.exp: print *obj3 +Running ./gdb.cp/shadow.exp ... +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker1 +PASS: gdb.cp/shadow.exp: Print class x shadowing global x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker2 +PASS: gdb.cp/shadow.exp: Print local x shadowing class x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker3 +PASS: gdb.cp/shadow.exp: Print inner scope x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker4 +PASS: gdb.cp/shadow.exp: Print local x not namespace x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker5 +PASS: gdb.cp/shadow.exp: Print imported namespace x +Running ./gdb.cp/smartp.exp ... +PASS: gdb.cp/smartp.exp: continue to breakpoint: end of main +PASS: gdb.cp/smartp.exp: p mp->foo() +PASS: gdb.cp/smartp.exp: p mtp->foo() +PASS: gdb.cp/smartp.exp: p mt1.foo() +PASS: gdb.cp/smartp.exp: p mt4p.a +PASS: gdb.cp/smartp.exp: p mt4->a +PASS: gdb.cp/smartp.exp: p sp1->foo() +PASS: gdb.cp/smartp.exp: p sp2->foo() +PASS: gdb.cp/smartp.exp: p sp3->foo(1) +PASS: gdb.cp/smartp.exp: p sp3->foo('a') +PASS: gdb.cp/smartp.exp: p sp4->a +PASS: gdb.cp/smartp.exp: p sp4->b +PASS: gdb.cp/smartp.exp: p mt4p->a +PASS: gdb.cp/smartp.exp: p mt4p->b +PASS: gdb.cp/smartp.exp: p mt4->fake +PASS: gdb.cp/smartp.exp: p mt4->fake() +PASS: gdb.cp/smartp.exp: p b->foo() +PASS: gdb.cp/smartp.exp: p c->foo() +PASS: gdb.cp/smartp.exp: p c->inta +KFAIL: gdb.cp/smartp.exp: p c2->inta (PRMS: gdb/11606) +Running ./gdb.cp/static-method.exp ... +PASS: gdb.cp/static-method.exp: info addr A::func() +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::A::func' +Running ./gdb.cp/static-print-quit.exp ... +PASS: gdb.cp/static-print-quit.exp: set width 80 +PASS: gdb.cp/static-print-quit.exp: set height 2 +PASS: gdb.cp/static-print-quit.exp: print c - <return> +PASS: gdb.cp/static-print-quit.exp: print c - q <return> +PASS: gdb.cp/static-print-quit.exp: print c - to quit +PASS: gdb.cp/static-print-quit.exp: q +PASS: gdb.cp/static-print-quit.exp: set pagination off +PASS: gdb.cp/static-print-quit.exp: first print +PASS: gdb.cp/static-print-quit.exp: second print +Running ./gdb.cp/temargs.exp ... +PASS: gdb.cp/temargs.exp: set first breakpoint for temargs +PASS: gdb.cp/temargs.exp: set second breakpoint for temargs +PASS: gdb.cp/temargs.exp: set third breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set sixth breakpoint for temargs +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to first breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in base_m +PASS: gdb.cp/temargs.exp: test value of I in base_m +PASS: gdb.cp/temargs.exp: test value of P in base_m +PASS: gdb.cp/temargs.exp: test value of MP in base_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to second breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in inner_m +PASS: gdb.cp/temargs.exp: test value of I in inner_m +PASS: gdb.cp/temargs.exp: test value of P in inner_m +PASS: gdb.cp/temargs.exp: test value of MP in inner_m +PASS: gdb.cp/temargs.exp: test type of Z in inner_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to third breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in func +PASS: gdb.cp/temargs.exp: test value of I in func +PASS: gdb.cp/temargs.exp: test value of P in func +PASS: gdb.cp/temargs.exp: test value of MP in func +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in templ_m +PASS: gdb.cp/temargs.exp: test value of I in templ_m +PASS: gdb.cp/temargs.exp: test value of P in templ_m +PASS: gdb.cp/temargs.exp: test value of MP in templ_m +PASS: gdb.cp/temargs.exp: test type of Q in templ_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of F in k2_m +XFAIL: gdb.cp/temargs.exp: test value of F in k2_m (PRMS gcc/49366) +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to sixth breakpoint for temargs +XFAIL: gdb.cp/temargs.exp: test type of F in k3_m (PRMS gcc/49546) +XFAIL: gdb.cp/temargs.exp: test value of F in k3_m (PRMS gcc/49546) +Running ./gdb.cp/templates.exp ... +PASS: gdb.cp/templates.exp: set multiple-symbols ask +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +PASS: gdb.cp/templates.exp: constructor breakpoint +PASS: gdb.cp/templates.exp: destructor breakpoint +PASS: gdb.cp/templates.exp: value method breakpoint +PASS: gdb.cp/templates.exp: breakpoint on a line with no real code +PASS: gdb.cp/templates.exp: print method of template typedef +XFAIL: gdb.cp/templates.exp: print destructor of template typedef (PRMS gcc/51668) +PASS: gdb.cp/templates.exp: verify GCC PR debug/51668 +PASS: gdb.cp/templates.exp: ptype empty +PASS: gdb.cp/templates.exp: ptype arg +PASS: gdb.cp/templates.exp: print t5i.value() +PASS: gdb.cp/templates.exp: b 770 +PASS: gdb.cp/templates.exp: continue to line 770 +PASS: gdb.cp/templates.exp: print fint +PASS: gdb.cp/templates.exp: print fvpchar +PASS: gdb.cp/templates.exp: ptype Foo +PASS: gdb.cp/templates.exp: ptype fint +PASS: gdb.cp/templates.exp: ptype fchar +KFAIL: gdb.cp/templates.exp: ptype fvpchar (PRMS: gdb/1512) +PASS: gdb.cp/templates.exp: print Foo<volatile char *>::foo +PASS: gdb.cp/templates.exp: print Foo<volatile char*>::foo +PASS: gdb.cp/templates.exp: ptype Bar +PASS: gdb.cp/templates.exp: ptype bint +PASS: gdb.cp/templates.exp: ptype bint2 +PASS: gdb.cp/templates.exp: ptype Baz +PASS: gdb.cp/templates.exp: ptype bazint +PASS: gdb.cp/templates.exp: ptype bazint2 +PASS: gdb.cp/templates.exp: ptype Qux +PASS: gdb.cp/templates.exp: ptype quxint +PASS: gdb.cp/templates.exp: ptype Spec +PASS: gdb.cp/templates.exp: ptype siip +PASS: gdb.cp/templates.exp: ptype Garply<int> +PASS: gdb.cp/templates.exp: ptype Garply<Garply<char> > +PASS: gdb.cp/templates.exp: print Garply<Garply<char> >::garply +PASS: gdb.cp/templates.exp: break Garply<Garply<char> >::garply +Running ./gdb.cp/try_catch.exp ... +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-start +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-next +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-catch +Running ./gdb.cp/typedef-operator.exp ... +PASS: gdb.cp/typedef-operator.exp: set language c++ +PASS: gdb.cp/typedef-operator.exp: test crash +PASS: gdb.cp/typedef-operator.exp: test typedef +Running ./gdb.cp/userdef.exp ... +PASS: gdb.cp/userdef.exp: break marker1 +PASS: gdb.cp/userdef.exp: continue to marker1 +PASS: gdb.cp/userdef.exp: up from marker1 +PASS: gdb.cp/userdef.exp: print one + two +PASS: gdb.cp/userdef.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/userdef.exp: print one - two +PASS: gdb.cp/userdef.exp: print one * two +PASS: gdb.cp/userdef.exp: print one / two +PASS: gdb.cp/userdef.exp: print one % two +PASS: gdb.cp/userdef.exp: print one && two +PASS: gdb.cp/userdef.exp: print one || two +PASS: gdb.cp/userdef.exp: print one & two +PASS: gdb.cp/userdef.exp: print one | two +PASS: gdb.cp/userdef.exp: print one ^ two +PASS: gdb.cp/userdef.exp: print one < two +PASS: gdb.cp/userdef.exp: print one <= two +PASS: gdb.cp/userdef.exp: print one > two +PASS: gdb.cp/userdef.exp: print one >= two +PASS: gdb.cp/userdef.exp: print one == two +PASS: gdb.cp/userdef.exp: print one.operator== (two) +PASS: gdb.cp/userdef.exp: print one != two +PASS: gdb.cp/userdef.exp: print one << 31 +PASS: gdb.cp/userdef.exp: print one >> 31 +PASS: gdb.cp/userdef.exp: print !one +PASS: gdb.cp/userdef.exp: print +one +PASS: gdb.cp/userdef.exp: print ~one +PASS: gdb.cp/userdef.exp: print -one +PASS: gdb.cp/userdef.exp: print one++ +PASS: gdb.cp/userdef.exp: print ++one +PASS: gdb.cp/userdef.exp: print one-- +PASS: gdb.cp/userdef.exp: print --one +PASS: gdb.cp/userdef.exp: print one += 7 +PASS: gdb.cp/userdef.exp: print two = one +PASS: gdb.cp/userdef.exp: break A2::operator+ +PASS: gdb.cp/userdef.exp: break A2::operator + +PASS: gdb.cp/userdef.exp: print c +PASS: gdb.cp/userdef.exp: print *c +PASS: gdb.cp/userdef.exp: print &*c +PASS: gdb.cp/userdef.exp: ptype &*c +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem2) +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem1) +Running ./gdb.cp/using-crash.exp ... +PASS: gdb.cp/using-crash.exp: reload file +Running ./gdb.cp/virtbase.exp ... +PASS: gdb.cp/virtbase.exp: continue to breakpoint: first breakpoint +PASS: gdb.cp/virtbase.exp: print *this +PASS: gdb.cp/virtbase.exp: print x in get_y +PASS: gdb.cp/virtbase.exp: continue to breakpoint: second breakpoint +PASS: gdb.cp/virtbase.exp: print x in get_z +PASS: gdb.cp/virtbase.exp: continue to breakpoint: third breakpoint +PASS: gdb.cp/virtbase.exp: print *(D *) e +PASS: gdb.cp/virtbase.exp: set print object on +PASS: gdb.cp/virtbase.exp: print/x b->mA +PASS: gdb.cp/virtbase.exp: print rtti_data +PASS: gdb.cp/virtbase.exp: print pointer to virtual base at non-zero offset of larger object +PASS: gdb.cp/virtbase.exp: print same pointer from history value +PASS: gdb.cp/virtbase.exp: print whole pointed-to object, starting from the virtual base pointer +Running ./gdb.cp/virtfunc2.exp ... +PASS: gdb.cp/virtfunc2.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/virtfunc2.exp: print o.do_print() +PASS: gdb.cp/virtfunc2.exp: print o.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print2() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o +Running ./gdb.cp/virtfunc.exp ... +PASS: gdb.cp/virtfunc.exp: ptype VA +PASS: gdb.cp/virtfunc.exp: ptype VB +PASS: gdb.cp/virtfunc.exp: ptype V +PASS: gdb.cp/virtfunc.exp: ptype A +PASS: gdb.cp/virtfunc.exp: ptype B +PASS: gdb.cp/virtfunc.exp: ptype C +PASS: gdb.cp/virtfunc.exp: ptype AD +PASS: gdb.cp/virtfunc.exp: ptype D +PASS: gdb.cp/virtfunc.exp: ptype E +PASS: gdb.cp/virtfunc.exp: ptype dd +PASS: gdb.cp/virtfunc.exp: ptype ppd +PASS: gdb.cp/virtfunc.exp: ptype pAd +PASS: gdb.cp/virtfunc.exp: ptype a +PASS: gdb.cp/virtfunc.exp: ptype b +PASS: gdb.cp/virtfunc.exp: ptype c +PASS: gdb.cp/virtfunc.exp: ptype d +PASS: gdb.cp/virtfunc.exp: ptype e +PASS: gdb.cp/virtfunc.exp: ptype v +PASS: gdb.cp/virtfunc.exp: ptype vb +PASS: gdb.cp/virtfunc.exp: ptype pAa +PASS: gdb.cp/virtfunc.exp: ptype pAe +PASS: gdb.cp/virtfunc.exp: ptype pBe +PASS: gdb.cp/virtfunc.exp: ptype pDd +PASS: gdb.cp/virtfunc.exp: ptype pDe +PASS: gdb.cp/virtfunc.exp: ptype pVa +PASS: gdb.cp/virtfunc.exp: ptype pVv +PASS: gdb.cp/virtfunc.exp: ptype pVe +PASS: gdb.cp/virtfunc.exp: ptype pVd +PASS: gdb.cp/virtfunc.exp: ptype pADe +PASS: gdb.cp/virtfunc.exp: ptype pEe +PASS: gdb.cp/virtfunc.exp: ptype pVB +PASS: gdb.cp/virtfunc.exp: info vtbl a +PASS: gdb.cp/virtfunc.exp: info vtbl b +PASS: gdb.cp/virtfunc.exp: info vtbl c +PASS: gdb.cp/virtfunc.exp: info vtbl d +PASS: gdb.cp/virtfunc.exp: info vtbl e +PASS: gdb.cp/virtfunc.exp: info vtbl pEe +PASS: gdb.cp/virtfunc.exp: info vtbl +PASS: gdb.cp/virtfunc.exp: info vtbl va +PASS: gdb.cp/virtfunc.exp: info vtbl all_count +PASS: gdb.cp/virtfunc.exp: print pAe->f() +PASS: gdb.cp/virtfunc.exp: print pAa->f() +PASS: gdb.cp/virtfunc.exp: print pDe->vg() +PASS: gdb.cp/virtfunc.exp: print pADe->vg() +PASS: gdb.cp/virtfunc.exp: print pDd->vg() +PASS: gdb.cp/virtfunc.exp: print pEe->vvb() +PASS: gdb.cp/virtfunc.exp: print pVB->vvb() +PASS: gdb.cp/virtfunc.exp: print pBe->vvb() +PASS: gdb.cp/virtfunc.exp: print pDe->vvb() +PASS: gdb.cp/virtfunc.exp: print pEe->vd() +PASS: gdb.cp/virtfunc.exp: print pEe->fvb() +KFAIL: gdb.cp/virtfunc.exp: print pEe->D::vg() (PRMS: gdb/1064) +PASS: gdb.cp/virtfunc.exp: next to pAa->f call +PASS: gdb.cp/virtfunc.exp: next to pDe->vg call +PASS: gdb.cp/virtfunc.exp: step through thunk into E::vg +Running ./gdb.disasm/am33.exp ... +Running ./gdb.disasm/h8300s.exp ... +Running ./gdb.disasm/hppa.exp ... +Running ./gdb.disasm/mn10300.exp ... +Running ./gdb.disasm/sh3.exp ... +Running ./gdb.disasm/t01_mov.exp ... +Running ./gdb.disasm/t02_mova.exp ... +Running ./gdb.disasm/t03_add.exp ... +Running ./gdb.disasm/t04_sub.exp ... +Running ./gdb.disasm/t05_cmp.exp ... +Running ./gdb.disasm/t06_ari2.exp ... +Running ./gdb.disasm/t07_ari3.exp ... +Running ./gdb.disasm/t08_or.exp ... +Running ./gdb.disasm/t09_xor.exp ... +Running ./gdb.disasm/t10_and.exp ... +Running ./gdb.disasm/t11_logs.exp ... +Running ./gdb.disasm/t12_bit.exp ... +Running ./gdb.disasm/t13_otr.exp ... +Running ./gdb.dwarf2/callframecfa.exp ... +PASS: gdb.dwarf2/callframecfa.exp: set breakpoint for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: continue to breakpoint: continue to breakpoint for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: set display for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: step 1 for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: step 2 for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: step 3 for call-frame-cfa +PASS: gdb.dwarf2/callframecfa.exp: step 4 for call-frame-cfa +Running ./gdb.dwarf2/clztest.exp ... +Running ./gdb.dwarf2/dup-psym.exp ... +PASS: gdb.dwarf2/dup-psym.exp: info sources should contain only one reference to file1.txt +Running ./gdb.dwarf2/dw2-ada-ffffffff.exp ... +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: p sizeof (t) +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: ptype t +Running ./gdb.dwarf2/dw2-anon-mptr.exp ... +PASS: gdb.dwarf2/dw2-anon-mptr.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-anon-mptr.exp: show cp-abi +PASS: gdb.dwarf2/dw2-anon-mptr.exp: ptype crash +Running ./gdb.dwarf2/dw2-anonymous-func.exp ... +PASS: gdb.dwarf2/dw2-anonymous-func.exp: list file1.txt +Running ./gdb.dwarf2/dw2-bad-parameter-type.exp ... +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: is alive +Running ./gdb.dwarf2/dw2-basic.exp ... +PASS: gdb.dwarf2/dw2-basic.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-basic.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-basic.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-canonicalize-type.exp ... +PASS: gdb.dwarf2/dw2-canonicalize-type.exp: ptype f +Running ./gdb.dwarf2/dw2-case-insensitive.exp ... +PASS: gdb.dwarf2/dw2-case-insensitive.exp: show case-sensitive +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive on +PASS: gdb.dwarf2/dw2-case-insensitive.exp: set case-sensitive off +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive off +PASS: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_symtab +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_symtab +Running ./gdb.dwarf2/dw2-common-block.exp ... +Running ./gdb.dwarf2/dw2-compdir-oldgcc.exp ... +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc43 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc43 +Running ./gdb.dwarf2/dw2-compressed.exp ... +PASS: gdb.dwarf2/dw2-compressed.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-compressed.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-compressed.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-const.exp ... +PASS: gdb.dwarf2/dw2-const.exp: print twelve +PASS: gdb.dwarf2/dw2-const.exp: print/x val8 +Running ./gdb.dwarf2/dw2-cp-infcall-ref-static.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-cp-infcall-ref-static.exp: dw2-cp-infcall-ref-static.exp +Running ./gdb.dwarf2/dw2-cu-size.exp ... +PASS: gdb.dwarf2/dw2-cu-size.exp: ptype noloc +Running ./gdb.dwarf2/dw2-dir-file-name.exp ... +PASS: gdb.dwarf2/dw2-dir-file-name.exp: cd .../rdir +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: continue to breakpoint: compdir_missing__ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: continue to breakpoint: compdir_missing__ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: continue to breakpoint: compdir_missing__ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: continue to breakpoint: compdir_missing__ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: continue to breakpoint: compdir_missing__ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: continue to breakpoint: compdir_missing__ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: continue to breakpoint: compdir_missing__ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: continue to breakpoint: compdir_missing__ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: continue to breakpoint: compdir_relative_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: continue to breakpoint: compdir_relative_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: continue to breakpoint: compdir_relative_ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: continue to breakpoint: compdir_relative_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: continue to breakpoint: compdir_relative_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: continue to breakpoint: compdir_relative_ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: continue to breakpoint: compdir_relative_ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: continue to breakpoint: compdir_relative_ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: continue to breakpoint: compdir_absolute_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: continue to breakpoint: compdir_absolute_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: continue to breakpoint: compdir_absolute_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: continue to breakpoint: compdir_absolute_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_basename_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_relative_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: relative +Running ./gdb.dwarf2/dw2-dos-drive.exp ... +PASS: gdb.dwarf2/dw2-dos-drive.exp: set breakpoint pending off +PASS: gdb.dwarf2/dw2-dos-drive.exp: break 'z:file.c':func +UNSUPPORTED: gdb.dwarf2/dw2-dos-drive.exp: break file.c:func +Running ./gdb.dwarf2/dw2-double-set-die-type.exp ... +PASS: gdb.dwarf2/dw2-double-set-die-type.exp: ptype a +Running ./gdb.dwarf2/dw2-empty-namespace.exp ... +PASS: gdb.dwarf2/dw2-empty-namespace.exp: ptype var +PASS: gdb.dwarf2/dw2-empty-namespace.exp: p var +Running ./gdb.dwarf2/dw2-empty-pc-range.exp ... +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range before CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: valid range after CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range after CU load +Running ./gdb.dwarf2/dw2-entry-value.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-entry-value.exp: dw2-entry-value.exp +Running ./gdb.dwarf2/dw2-error.exp ... +gdb compile failed, dw2-error.c: Assembler messages: +dw2-error.c:33: Error: bad register name `%rbp' +dw2-error.c:36: Error: bad register name `%rsp' +dw2-error.c:43: Error: bad register name `%rbp' +UNTESTED: gdb.dwarf2/dw2-error.exp: dw2-error.exp +Running ./gdb.dwarf2/dw2-filename.exp ... +PASS: gdb.dwarf2/dw2-filename.exp: interpreter-exec mi -file-list-exec-source-files +PASS: gdb.dwarf2/dw2-filename.exp: info sources +Running ./gdb.dwarf2/dw2-icc-opaque.exp ... +PASS: gdb.dwarf2/dw2-icc-opaque.exp: ptype p_struct +Running ./gdb.dwarf2/dw2-ifort-parameter.exp ... +PASS: gdb.dwarf2/dw2-ifort-parameter.exp: p/x param +Running ./gdb.dwarf2/dw2-inheritance.exp ... +PASS: gdb.dwarf2/dw2-inheritance.exp: ptype inherited +Running ./gdb.dwarf2/dw2-inline-break.exp ... +Running ./gdb.dwarf2/dw2-inline-param.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-inline-param.exp: dw2-inline-param.exp +Running ./gdb.dwarf2/dw2-intercu.exp ... +PASS: gdb.dwarf2/dw2-intercu.exp: ptype int2 +PASS: gdb.dwarf2/dw2-intercu.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-intercu.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-intercu.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-intermix.exp ... +PASS: gdb.dwarf2/dw2-intermix.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-intermix.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-intermix.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-linkage-name-trust.exp ... +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set language c++ +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername () +Running ./gdb.dwarf2/dw2-minsym-in-cu.exp ... +PASS: gdb.dwarf2/dw2-minsym-in-cu.exp: info fun func2 +Running ./gdb.dwarf2/dw2-modula2-self-type.exp ... +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: set language modula-2 +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: ptype v +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: alive +Running ./gdb.dwarf2/dw2-namespaceless-anonymous.exp ... +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: ptype '(anonymous namespace)::v' +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: p '(anonymous namespace)::v' +Running ./gdb.dwarf2/dw2-noloc.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-noloc.exp: dw2-noloc.exp +Running ./gdb.dwarf2/dw2-objfile-overlap.exp ... +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: add-symbol-file +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: info line inner +Running ./gdb.dwarf2/dw2-op-call.exp ... +PASS: gdb.dwarf2/dw2-op-call.exp: maintenance set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw2-op-call.exp: p array1 +PASS: gdb.dwarf2/dw2-op-call.exp: array2 using DW_OP_call2 +PASS: gdb.dwarf2/dw2-op-call.exp: array3 using DW_OP_call4 +PASS: gdb.dwarf2/dw2-op-call.exp: p arraynoloc +PASS: gdb.dwarf2/dw2-op-call.exp: p arraycallnoloc +Running ./gdb.dwarf2/dw2-op-out-param.exp ... +Running ./gdb.dwarf2/dw2-op-stack-value.exp ... +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack8 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: x/wx &aa551234 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to4 +Running ./gdb.dwarf2/dw2-param-error.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-param-error.exp: dw2-param-error.exp +Running ./gdb.dwarf2/dw2-producer.exp ... +PASS: gdb.dwarf2/dw2-producer.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-producer.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-producer.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-ranges.exp ... +PASS: gdb.dwarf2/dw2-ranges.exp: info line main +PASS: gdb.dwarf2/dw2-ranges.exp: info line func +PASS: gdb.dwarf2/dw2-ranges.exp: info line main2 +PASS: gdb.dwarf2/dw2-ranges.exp: info line func2 +KFAIL: gdb.dwarf2/dw2-ranges.exp: info line main3 (PRMS: symtab/12497) +Running ./gdb.dwarf2/dw2-ref-missing-frame.exp ... +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_nofb print +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_nofb backtrace +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb print +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb backtrace +Running ./gdb.dwarf2/dw2-restore.exp ... +Running ./gdb.dwarf2/dw2-restrict.exp ... +Running ./gdb.dwarf2/dw2-simple-locdesc.exp ... +KFAIL: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.shl (PRMS: symtab/13307) +PASS: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.data4 +Running ./gdb.dwarf2/dw2-skip-prologue.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-skip-prologue.exp: dw2-skip-prologue.exp +Running ./gdb.dwarf2/dw2-stack-boundary.exp ... +PASS: gdb.dwarf2/dw2-stack-boundary.exp: set complaints 100 +PASS: gdb.dwarf2/dw2-stack-boundary.exp: check partial symtab errors +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p underflow +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p overflow +Running ./gdb.dwarf2/dw2-strp.exp ... +PASS: gdb.dwarf2/dw2-strp.exp: p a_string +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string +PASS: gdb.dwarf2/dw2-strp.exp: p a_string2 +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string2 +Running ./gdb.dwarf2/dw2-unresolved.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-unresolved.exp: dw2-unresolved.exp +Running ./gdb.dwarf2/dw2-var-zero-addr.exp ... +PASS: gdb.dwarf2/dw2-var-zero-addr.exp: print &var +Running ./gdb.dwarf2/dw4-sig-types.exp ... +PASS: gdb.dwarf2/dw4-sig-types.exp: maint set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw4-sig-types.exp: p myset +PASS: gdb.dwarf2/dw4-sig-types.exp: continue to foo +Running ./gdb.dwarf2/dw4-sig-type-unused.exp ... +PASS: gdb.dwarf2/dw4-sig-type-unused.exp: alive +Running ./gdb.dwarf2/fission-base.exp ... +Running ./gdb.dwarf2/fission-loclists.exp ... +Running ./gdb.dwarf2/fission-reread.exp ... +PASS: gdb.dwarf2/fission-reread.exp: break main +PASS: gdb.dwarf2/fission-reread.exp: fission-reread +PASS: gdb.dwarf2/fission-reread.exp: fission-reread - unload +Running ./gdb.dwarf2/implptr-64bit.exp ... +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +UNTESTED: gdb.dwarf2/implptr-64bit.exp: implptr-64bit.exp +Running ./gdb.dwarf2/implptr.exp ... +PASS: gdb.dwarf2/implptr.exp: maintenance set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/implptr.exp: set bar breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: continue to breakpoint: continue to bar breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: print j in implptr:bar +PASS: gdb.dwarf2/implptr.exp: print sizeof (j[0]) in implptr:bar +PASS: gdb.dwarf2/implptr.exp: print *j in implptr:bar +PASS: gdb.dwarf2/implptr.exp: print **k in implptr:bar +PASS: gdb.dwarf2/implptr.exp: print ***l in implptr:bar +PASS: gdb.dwarf2/implptr.exp: set baz breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: continue to breakpoint: continue to baz breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: sanity check element 0 +PASS: gdb.dwarf2/implptr.exp: sanity check element 1 +PASS: gdb.dwarf2/implptr.exp: enter the inlined function +PASS: gdb.dwarf2/implptr.exp: check element 0 for the offset +PASS: gdb.dwarf2/implptr.exp: check element 1 for the offset +PASS: gdb.dwarf2/implptr.exp: continue to breakpoint: ignore the second baz breakpoint +PASS: gdb.dwarf2/implptr.exp: set foo breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: continue to breakpoint: continue to foo breakpoint for implptr +PASS: gdb.dwarf2/implptr.exp: print p[0].x in implptr:foo +PASS: gdb.dwarf2/implptr.exp: print *p[0].x in implptr:foo +PASS: gdb.dwarf2/implptr.exp: print byte inside *p[0].x in implptr:foo +PASS: gdb.dwarf2/implptr.exp: print invalid offset from *p[0].x in implptr:foo +PASS: gdb.dwarf2/implptr.exp: print j in implptr:foo +Running ./gdb.dwarf2/implptr-optimized-out.exp ... +PASS: gdb.dwarf2/implptr-optimized-out.exp: p p->f +Running ./gdb.dwarf2/mac-fileno.exp ... +PASS: gdb.dwarf2/mac-fileno.exp: set listsize 1 +PASS: gdb.dwarf2/mac-fileno.exp: list func_cu1 +PASS: gdb.dwarf2/mac-fileno.exp: ptype func_cu1 +Running ./gdb.dwarf2/member-ptr-forwardref.exp ... +PASS: gdb.dwarf2/member-ptr-forwardref.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/member-ptr-forwardref.exp: show cp-abi +PASS: gdb.dwarf2/member-ptr-forwardref.exp: ptype c +Running ./gdb.dwarf2/method-ptr.exp ... +PASS: gdb.dwarf2/method-ptr.exp: ptype the_typedef +Running ./gdb.dwarf2/pieces.exp ... +PASS: gdb.dwarf2/pieces.exp: set f1 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: continue to breakpoint: continue to f1 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: print a in pieces:f1 +PASS: gdb.dwarf2/pieces.exp: print a.j in pieces:f1 +PASS: gdb.dwarf2/pieces.exp: set f2 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: continue to breakpoint: continue to f2 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: print a in pieces:f2 +PASS: gdb.dwarf2/pieces.exp: print a[0] in pieces:f2 +PASS: gdb.dwarf2/pieces.exp: print a[1] in pieces:f2 +PASS: gdb.dwarf2/pieces.exp: set f3 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: continue to breakpoint: continue to f3 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: print a.i in pieces:f3 +PASS: gdb.dwarf2/pieces.exp: print a.j in pieces:f3 +PASS: gdb.dwarf2/pieces.exp: set a.i in pieces:f3 +PASS: gdb.dwarf2/pieces.exp: print new a.i in pieces:f3 +PASS: gdb.dwarf2/pieces.exp: set f6 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: continue to breakpoint: continue to f6 breakpoint for pieces +PASS: gdb.dwarf2/pieces.exp: print a with optimized out piece +PASS: gdb.dwarf2/pieces.exp: print a.i with optimized out piece +Running ./gdb.dwarf2/pr10770.exp ... +PASS: gdb.dwarf2/pr10770.exp: set breakpoint for pr10770 +PASS: gdb.dwarf2/pr10770.exp: cont +PASS: gdb.dwarf2/pr10770.exp: frame 2 +Running ./gdb.dwarf2/pr11465.exp ... +PASS: gdb.dwarf2/pr11465.exp: p N::c.C +Running ./gdb.dwarf2/pr13961.exp ... +PASS: gdb.dwarf2/pr13961.exp: break main +PASS: gdb.dwarf2/pr13961.exp: pr13961 +Running ./gdb.dwarf2/subrange.exp ... +PASS: gdb.dwarf2/subrange.exp: set language pascal +PASS: gdb.dwarf2/subrange.exp: ptype TByteArray +Running ./gdb.dwarf2/trace-crash.exp ... +Running ./gdb.dwarf2/typeddwarf.exp ... +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of j at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of l at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of m at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of n at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of o at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of p at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of q at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of r at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of s at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of t at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of u at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of v at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of j at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of l at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of m at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of p at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of q at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of r at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of s at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of t at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of u at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of v at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of z at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of z at typeddwarf.c:73 +Running ./gdb.dwarf2/valop.exp ... +PASS: gdb.dwarf2/valop.exp: set breakpoint for valop +PASS: gdb.dwarf2/valop.exp: continue to breakpoint: continue to breakpoint for valop +PASS: gdb.dwarf2/valop.exp: print uses_stack_op +PASS: gdb.dwarf2/valop.exp: print uses_lit_op +Running ./gdb.dwarf2/watch-notconst.exp ... +PASS: gdb.dwarf2/watch-notconst.exp: watch x +Running ./gdb.fortran/array-element.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/array-element.exp: array-element.exp +Running ./gdb.fortran/charset.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/charset.exp: charset.exp +Running ./gdb.fortran/common-block.exp ... +UNTESTED: gdb.fortran/common-block.exp: common-block.exp +Running ./gdb.fortran/complex.exp ... +UNTESTED: gdb.fortran/complex.exp: complex.exp +UNTESTED: gdb.fortran/complex.exp: Couldn't compile complex.f +Running ./gdb.fortran/derived-type.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/derived-type.exp: derived-type.exp +Running ./gdb.fortran/exprs.exp ... +PASS: gdb.fortran/exprs.exp: set print sevenbit-strings +PASS: gdb.fortran/exprs.exp: set language fortran +PASS: gdb.fortran/exprs.exp: set language to "fortran" +PASS: gdb.fortran/exprs.exp: Set value-history[1] using $1 +PASS: gdb.fortran/exprs.exp: Set value-history[2] using $2 +PASS: gdb.fortran/exprs.exp: Set value-history[3] using $3 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.fortran/exprs.exp: Print value-history[1] using explicit index $1 +PASS: gdb.fortran/exprs.exp: Print value-history[2] using explicit index $2 +PASS: gdb.fortran/exprs.exp: Print value-history[3] using explicit index $3 +PASS: gdb.fortran/exprs.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.fortran/exprs.exp: Use value-history element in arithmetic expression +PASS: gdb.fortran/exprs.exp: Set a new convenience variable +PASS: gdb.fortran/exprs.exp: Print contents of new convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable to a new value +PASS: gdb.fortran/exprs.exp: Print new contents of convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable $_ +PASS: gdb.fortran/exprs.exp: Print contents of convenience variable $_ +PASS: gdb.fortran/exprs.exp: Use convenience variable in arithmetic expression +PASS: gdb.fortran/exprs.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.fortran/exprs.exp: Print contents of uninitialized convenience variable +PASS: gdb.fortran/exprs.exp: p 123 +PASS: gdb.fortran/exprs.exp: p -123 +PASS: gdb.fortran/exprs.exp: reject p _ +PASS: gdb.fortran/exprs.exp: p .TRUE. +PASS: gdb.fortran/exprs.exp: p .FALSE. +PASS: gdb.fortran/exprs.exp: p 'a' +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(2:4) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:3) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(5:) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:) +PASS: gdb.fortran/exprs.exp: p .44 .LT. .45 +PASS: gdb.fortran/exprs.exp: p .44 .GT. .45 +PASS: gdb.fortran/exprs.exp: p 0.44 .LT. 0.45 +PASS: gdb.fortran/exprs.exp: p 0.44 .GT. 0.45 +PASS: gdb.fortran/exprs.exp: p 44. .LT. 45. +PASS: gdb.fortran/exprs.exp: p 44. .GT. 45. +PASS: gdb.fortran/exprs.exp: p 44.0 .LT. 45.0 +PASS: gdb.fortran/exprs.exp: p 44.0 .GT. 45.0 +PASS: gdb.fortran/exprs.exp: p 10D20 .LT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10D20 .GT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10d20 .LT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10d20 .GT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10E20 .LT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10E20 .GT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10e20 .LT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10e20 .GT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .LT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .GT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .LT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .GT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .LT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .GT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .LT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .GT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .LT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .GT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .LT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .GT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .LT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .GT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .LT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .GT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .LT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .GT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .LT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .GT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .LT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .GT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .LT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .GT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .LT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .GT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .LT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .GT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .LT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .GT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .LT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .GT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: unary minus applied to int +PASS: gdb.fortran/exprs.exp: unary minus applied to real +PASS: gdb.fortran/exprs.exp: bool plus int +PASS: gdb.fortran/exprs.exp: int plus int +PASS: gdb.fortran/exprs.exp: real plus int +PASS: gdb.fortran/exprs.exp: real plus real +PASS: gdb.fortran/exprs.exp: bool minus int +PASS: gdb.fortran/exprs.exp: int minus int +PASS: gdb.fortran/exprs.exp: real minus int +PASS: gdb.fortran/exprs.exp: real minus real +PASS: gdb.fortran/exprs.exp: bool times int +PASS: gdb.fortran/exprs.exp: int times int +PASS: gdb.fortran/exprs.exp: real times int +PASS: gdb.fortran/exprs.exp: real times real +PASS: gdb.fortran/exprs.exp: bool divided by int +PASS: gdb.fortran/exprs.exp: int divided by int +PASS: gdb.fortran/exprs.exp: real divided by int +PASS: gdb.fortran/exprs.exp: real divided by real +PASS: gdb.fortran/exprs.exp: int powered by int +PASS: gdb.fortran/exprs.exp: combined exponentiation expression +PASS: gdb.fortran/exprs.exp: combined exponentiation expression in specified order +PASS: gdb.fortran/exprs.exp: int powered by real +PASS: gdb.fortran/exprs.exp: real powered by real +Running ./gdb.fortran/library-module.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/library-module.exp: Couldn't compile library-module-lib.f90 +Running ./gdb.fortran/logical.exp ... +UNTESTED: gdb.fortran/logical.exp: logical.exp +Running ./gdb.fortran/module.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/module.exp: module.exp +Running ./gdb.fortran/multi-dim.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/multi-dim.exp: multi-dim.exp +Running ./gdb.fortran/subarray.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gfortran. +UNTESTED: gdb.fortran/subarray.exp: subarray.exp +Running ./gdb.fortran/types.exp ... +PASS: gdb.fortran/types.exp: set print sevenbit-strings +PASS: gdb.fortran/types.exp: set language fortran +PASS: gdb.fortran/types.exp: set language to "fortran" +PASS: gdb.fortran/types.exp: pt 123 +PASS: gdb.fortran/types.exp: reject pt _ +PASS: gdb.fortran/types.exp: pt .TRUE. +PASS: gdb.fortran/types.exp: pt .FALSE. +PASS: gdb.fortran/types.exp: pt 'a' +PASS: gdb.fortran/types.exp: pt .44 +PASS: gdb.fortran/types.exp: pt 44.0 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10e20 +PASS: gdb.fortran/types.exp: pt 10e20 +Running ./gdb.gdb/complaints.exp ... +Running ./gdb.gdb/observer.exp ... +Running ./gdb.gdb/selftest.exp ... +Running ./gdb.gdb/xfullpath.exp ... +Running ./gdb.go/basic-types.exp ... +PASS: gdb.go/basic-types.exp: set language go +PASS: gdb.go/basic-types.exp: set language to "go" +PASS: gdb.go/basic-types.exp: pt 123 +PASS: gdb.go/basic-types.exp: pt void(42) +PASS: gdb.go/basic-types.exp: pt byte(42) +PASS: gdb.go/basic-types.exp: pt int(42) +PASS: gdb.go/basic-types.exp: pt uint(42) +PASS: gdb.go/basic-types.exp: pt uintptr(42) +PASS: gdb.go/basic-types.exp: pt int8(42) +PASS: gdb.go/basic-types.exp: pt int16(42) +PASS: gdb.go/basic-types.exp: pt int32(42) +PASS: gdb.go/basic-types.exp: pt int64(42) +PASS: gdb.go/basic-types.exp: pt uint8(42) +PASS: gdb.go/basic-types.exp: pt uint16(42) +PASS: gdb.go/basic-types.exp: pt uint32(42) +PASS: gdb.go/basic-types.exp: pt uint64(42) +PASS: gdb.go/basic-types.exp: pt true +PASS: gdb.go/basic-types.exp: pt false +PASS: gdb.go/basic-types.exp: pt bool(0) +PASS: gdb.go/basic-types.exp: pt bool(1) +PASS: gdb.go/basic-types.exp: pt 'a' +PASS: gdb.go/basic-types.exp: pt "a simple string" +PASS: gdb.go/basic-types.exp: pt `a simple raw string` +PASS: gdb.go/basic-types.exp: pt .44 +PASS: gdb.go/basic-types.exp: pt 44.0 +PASS: gdb.go/basic-types.exp: pt 10e20 +PASS: gdb.go/basic-types.exp: pt 10E20 +PASS: gdb.go/basic-types.exp: pt float32(.42) +PASS: gdb.go/basic-types.exp: pt float64(.42) +PASS: gdb.go/basic-types.exp: pt complex64(.42) +XFAIL: gdb.go/basic-types.exp: pt complex64(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex64(i1.0) +PASS: gdb.go/basic-types.exp: pt complex128(.42) +XFAIL: gdb.go/basic-types.exp: pt complex128(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex128(i1.0) +Running ./gdb.go/chan.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/chan.exp: chan.exp +Running ./gdb.go/handcall.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/handcall.exp: handcall.exp +Running ./gdb.go/hello.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/hello.exp: hello.exp +Running ./gdb.go/integers.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/integers.exp: integers.exp +Running ./gdb.go/methods.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/methods.exp: methods.exp +Running ./gdb.go/package.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/package.exp: package +Running ./gdb.go/print.exp ... +PASS: gdb.go/print.exp: set language go +PASS: gdb.go/print.exp: set language to "go" +PASS: gdb.go/print.exp: check fp + text +PASS: gdb.go/print.exp: p 1. +PASS: gdb.go/print.exp: p 1.5 +PASS: gdb.go/print.exp: p 1.f +PASS: gdb.go/print.exp: p 1.5f +PASS: gdb.go/print.exp: p 1.l +PASS: gdb.go/print.exp: p 1.5l +PASS: gdb.go/print.exp: p 0x1.1 +PASS: gdb.go/print.exp: reject p 1.1x +PASS: gdb.go/print.exp: reject p 1.1ff +PASS: gdb.go/print.exp: reject p 1.1ll +Running ./gdb.go/strings.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/strings.exp: strings.exp +Running ./gdb.go/types.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/types.exp: types.exp +Running ./gdb.go/unsafe.exp ... +gdb compile failed, default_target_compile: Can't find i686-pc-linux-gnu-gccgo. +UNTESTED: gdb.go/unsafe.exp: unsafe.exp +Running ./gdb.java/jmain.exp ... +UNSUPPORTED: gdb.java/jmain.exp: compilation jmain.java +Running ./gdb.java/jmisc.exp ... +UNSUPPORTED: gdb.java/jmisc.exp: compilation jmisc.java +Running ./gdb.java/jnpe.exp ... +UNSUPPORTED: gdb.java/jnpe.exp: compilation jnpe.java +UNTESTED: gdb.java/jnpe.exp: Couldn't compile ./gdb.java/jnpe.java +Running ./gdb.java/jprint.exp ... +UNSUPPORTED: gdb.java/jprint.exp: compilation jprint.java +Running ./gdb.java/jv-exp.exp ... +PASS: gdb.java/jv-exp.exp: set print sevenbit-strings +PASS: gdb.java/jv-exp.exp: set width 0 +PASS: gdb.java/jv-exp.exp: set language java +PASS: gdb.java/jv-exp.exp: set language to "java" +PASS: gdb.java/jv-exp.exp: p 1 > 2 +PASS: gdb.java/jv-exp.exp: p 1 < 2 +Running ./gdb.java/jv-print.exp ... +PASS: gdb.java/jv-print.exp: print $pc +PASS: gdb.java/jv-print.exp: set print sevenbit-strings +PASS: gdb.java/jv-print.exp: set width 0 +PASS: gdb.java/jv-print.exp: set language java +PASS: gdb.java/jv-print.exp: set language to "java" +PASS: gdb.java/jv-print.exp: p 123 +PASS: gdb.java/jv-print.exp: p -123 +PASS: gdb.java/jv-print.exp: p/d 123 +PASS: gdb.java/jv-print.exp: p 0123 +PASS: gdb.java/jv-print.exp: p 00123 +PASS: gdb.java/jv-print.exp: p -0123 +PASS: gdb.java/jv-print.exp: p/o 0123 +PASS: gdb.java/jv-print.exp: p 0x123 +PASS: gdb.java/jv-print.exp: p -0x123 +PASS: gdb.java/jv-print.exp: p 0x0123 +PASS: gdb.java/jv-print.exp: p -0x0123 +PASS: gdb.java/jv-print.exp: p 0xABCDEF +PASS: gdb.java/jv-print.exp: p 0xabcdef +PASS: gdb.java/jv-print.exp: p 0xAbCdEf +PASS: gdb.java/jv-print.exp: p/x 0x123 +PASS: gdb.java/jv-print.exp: p 'a' +PASS: gdb.java/jv-print.exp: p/c 'a' +PASS: gdb.java/jv-print.exp: p/c 70 +PASS: gdb.java/jv-print.exp: p/x 'a' +PASS: gdb.java/jv-print.exp: p/d 'a' +PASS: gdb.java/jv-print.exp: p/t 'a' +PASS: gdb.java/jv-print.exp: p/x '\377' +PASS: gdb.java/jv-print.exp: p '\'' +PASS: gdb.java/jv-print.exp: p '\\' +PASS: gdb.java/jv-print.exp: reject p 0x +PASS: gdb.java/jv-print.exp: p '' +PASS: gdb.java/jv-print.exp: p ''' +PASS: gdb.java/jv-print.exp: reject p '\' +PASS: gdb.java/jv-print.exp: reject p '\\\' +PASS: gdb.java/jv-print.exp: reject p DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123foobar.bazfoo3 +PASS: gdb.java/jv-print.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.java/jv-print.exp: check for floating addition +PASS: gdb.java/jv-print.exp: reject p 09 +PASS: gdb.java/jv-print.exp: reject p 079 +PASS: gdb.java/jv-print.exp: reject p 0xG +PASS: gdb.java/jv-print.exp: reject p 0xAG +PASS: gdb.java/jv-print.exp: check fp + text +PASS: gdb.java/jv-print.exp: p 1. +PASS: gdb.java/jv-print.exp: p 1.5 +PASS: gdb.java/jv-print.exp: p 1.f +PASS: gdb.java/jv-print.exp: p 1.5f +PASS: gdb.java/jv-print.exp: p 1.d +PASS: gdb.java/jv-print.exp: p 1.5d +PASS: gdb.java/jv-print.exp: p 0x1.1 +PASS: gdb.java/jv-print.exp: reject p 1.1x +PASS: gdb.java/jv-print.exp: reject p 1.1ff +PASS: gdb.java/jv-print.exp: reject p 1.1dd +Running ./gdb.linespec/break-ask.exp ... +PASS: gdb.linespec/break-ask.exp: set multiple-symbols ask +PASS: gdb.linespec/break-ask.exp: set filename-display absolute +PASS: gdb.linespec/break-ask.exp: break twodup absolute +PASS: gdb.linespec/break-ask.exp: 0 +PASS: gdb.linespec/break-ask.exp: set filename-display relative +PASS: gdb.linespec/break-ask.exp: break twodup relative +PASS: gdb.linespec/break-ask.exp: 2 +PASS: gdb.linespec/break-ask.exp: expect breakpoint +PASS: gdb.linespec/break-ask.exp: info source +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere +PASS: gdb.linespec/break-ask.exp: break twodup relative other +PASS: gdb.linespec/break-ask.exp: 3 +PASS: gdb.linespec/break-ask.exp: expect breakpoint other +PASS: gdb.linespec/break-ask.exp: info source other +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere other +Running ./gdb.linespec/linespec.exp ... +PASS: gdb.linespec/linespec.exp: set multiple-symbols to all for linespec tests +PASS: gdb.linespec/linespec.exp: single-location break using dir/file:line +PASS: gdb.linespec/linespec.exp: clear breakpoint using dir/file:line +PASS: gdb.linespec/linespec.exp: multi-location break using file:line +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name and label +PASS: gdb.linespec/linespec.exp: complete condition +PASS: gdb.linespec/linespec.exp: disable pending breakpoints for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint on non-existent function +PASS: gdb.linespec/linespec.exp: set breakpoint at all instances of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at non-existent lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at specific instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint in body.h +PASS: gdb.linespec/linespec.exp: set breakpoint in f1 +PASS: gdb.linespec/linespec.exp: add inferior for linespec tests +PASS: gdb.linespec/linespec.exp: switch to inferior 2 for linespec tests +PASS: gdb.linespec/linespec.exp: set the new inferior file for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint at main in both inferiors +Running ./gdb.linespec/ls-dollar.exp ... +PASS: gdb.linespec/ls-dollar.exp: set listsize 1 +PASS: gdb.linespec/ls-dollar.exp: list $dollar_var +PASS: gdb.linespec/ls-dollar.exp: break $dollar_func +Running ./gdb.linespec/ls-errs.exp ... +PASS: gdb.linespec/ls-errs.exp: set breakpoint pending off +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break -100 +PASS: gdb.linespec/ls-errs.exp: break +500 +PASS: gdb.linespec/ls-errs.exp: break 1000 +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 1 +PASS: gdb.linespec/ls-errs.exp: break +10 1 +PASS: gdb.linespec/ls-errs.exp: break -10 1 +PASS: gdb.linespec/ls-errs.exp: break 3 +1 +PASS: gdb.linespec/ls-errs.exp: break +10 +1 +PASS: gdb.linespec/ls-errs.exp: break -10 +1 +PASS: gdb.linespec/ls-errs.exp: break 3 +100 +PASS: gdb.linespec/ls-errs.exp: break +10 +100 +PASS: gdb.linespec/ls-errs.exp: break -10 +100 +PASS: gdb.linespec/ls-errs.exp: break 3 -10 +PASS: gdb.linespec/ls-errs.exp: break +10 -10 +PASS: gdb.linespec/ls-errs.exp: break -10 -10 +PASS: gdb.linespec/ls-errs.exp: break 3 foo +PASS: gdb.linespec/ls-errs.exp: break +10 foo +PASS: gdb.linespec/ls-errs.exp: break -10 foo +PASS: gdb.linespec/ls-errs.exp: break this_file_doesn't_exist.c:3 +PASS: gdb.linespec/ls-errs.exp: break this file has spaces.c:3 +PASS: gdb.linespec/ls-errs.exp: break "file::colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'file::colons.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this "file" has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'this "file" has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'this 'file' has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this 'file' has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break "spaces: and :colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'more: :spaces: :and colons::.c':3 +PASS: gdb.linespec/ls-errs.exp: break "src-file.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'src-file.c:3 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 1 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 +100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 -100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:-100 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:-100" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:-100' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:+500 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:+500" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:+500' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:1000 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:1000" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:1000' +PASS: gdb.linespec/ls-errs.exp: break foobar +PASS: gdb.linespec/ls-errs.exp: break foo::bar +PASS: gdb.linespec/ls-errs.exp: break foo.bar +PASS: gdb.linespec/ls-errs.exp: break foo . +PASS: gdb.linespec/ls-errs.exp: break foo bar +PASS: gdb.linespec/ls-errs.exp: break foo 1 +PASS: gdb.linespec/ls-errs.exp: break foo 0 +PASS: gdb.linespec/ls-errs.exp: break foo +10 +PASS: gdb.linespec/ls-errs.exp: break foo -10 +PASS: gdb.linespec/ls-errs.exp: break foo +100 +PASS: gdb.linespec/ls-errs.exp: break foo -100 +PASS: gdb.linespec/ls-errs.exp: break main:there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main: there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main :there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main 3 +PASS: gdb.linespec/ls-errs.exp: break main +100 +PASS: gdb.linespec/ls-errs.exp: break main -100 +PASS: gdb.linespec/ls-errs.exp: break main foo +PASS: gdb.linespec/ls-errs.exp: break main:here 3 +PASS: gdb.linespec/ls-errs.exp: break main:here +100 +PASS: gdb.linespec/ls-errs.exp: break main:here -100 +PASS: gdb.linespec/ls-errs.exp: break main:here foo +PASS: gdb.linespec/ls-errs.exp: break if +PASS: gdb.linespec/ls-errs.exp: break task +PASS: gdb.linespec/ls-errs.exp: break thread +PASS: gdb.linespec/ls-errs.exp: break 'main.c'flubber +PASS: gdb.linespec/ls-errs.exp: break 'main.c',21 +PASS: gdb.linespec/ls-errs.exp: break 'main.c' +PASS: gdb.linespec/ls-errs.exp: break 'main.c'3 +PASS: gdb.linespec/ls-errs.exp: break 'main.c'+3 +PASS: gdb.linespec/ls-errs.exp: break $zippo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:$zippo +Running ./gdb.linespec/macro-relative.exp ... +FAIL: gdb.linespec/macro-relative.exp: info macro HEADER +Running ./gdb.linespec/skip-two.exp ... +PASS: gdb.linespec/skip-two.exp: skip function dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored from main +PASS: gdb.linespec/skip-two.exp: continue to breakpoint: n +PASS: gdb.linespec/skip-two.exp: dupname ignored from n +PASS: gdb.linespec/skip-two.exp: skip delete 1 +PASS: gdb.linespec/skip-two.exp: skip file thefile.cc +PASS: gdb.linespec/skip-two.exp: step into dupname +PASS: gdb.linespec/skip-two.exp: finish from dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored for thefile.cc +Running ./gdb.linespec/thread.exp ... +PASS: gdb.linespec/thread.exp: breakpoint line number in file +PASS: gdb.linespec/thread.exp: continue to breakpoint: 29 +PASS: gdb.linespec/thread.exp: setting breakpoint at thread +PASS: gdb.linespec/thread.exp: continue to breakpoint: thread function +Running ./gdb.mi/dw2-ref-missing-frame.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/i686-pc-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-i686-pc-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +Running ./gdb.mi/gdb2549.exp ... +PASS: gdb.mi/gdb2549.exp: wrong arguments +PASS: gdb.mi/gdb2549.exp: no executable +PASS: gdb.mi/gdb2549.exp: breakpoint at main +PASS: gdb.mi/gdb2549.exp: mi runto main +PASS: gdb.mi/gdb2549.exp: register values x +PASS: gdb.mi/gdb2549.exp: register values f +PASS: gdb.mi/gdb2549.exp: register values d +PASS: gdb.mi/gdb2549.exp: register values o +PASS: gdb.mi/gdb2549.exp: register values t +Running ./gdb.mi/gdb669.exp ... +PASS: gdb.mi/gdb669.exp: successfully compiled posix threads test case +PASS: gdb.mi/gdb669.exp: breakpoint at main +PASS: gdb.mi/gdb669.exp: mi runto main +PASS: gdb.mi/gdb669.exp: -thread-list-ids (at main) +PASS: gdb.mi/gdb669.exp: info threads (at main) +PASS: gdb.mi/gdb669.exp: finding MI result string (at main) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (at main) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (at main) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (at main) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (at main) +PASS: gdb.mi/gdb669.exp: next, try 0 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 0) +PASS: gdb.mi/gdb669.exp: info threads (try 0) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 0) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 0) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 0) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 0) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 0) +PASS: gdb.mi/gdb669.exp: next, try 1 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 1) +PASS: gdb.mi/gdb669.exp: info threads (try 1) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 1) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 1) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 1) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 1) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 1) +PASS: gdb.mi/gdb669.exp: next, try 2 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 2) +PASS: gdb.mi/gdb669.exp: info threads (try 2) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 2) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 2) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 2) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 2) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 2) +PASS: gdb.mi/gdb669.exp: next, try 3 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 3) +PASS: gdb.mi/gdb669.exp: info threads (try 3) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 3) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 3) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 3) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 3) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 3) +Running ./gdb.mi/gdb680.exp ... +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 0 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 1 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 2 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 3 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 4 +Running ./gdb.mi/gdb701.exp ... +PASS: gdb.mi/gdb701.exp: breakpoint at main +PASS: gdb.mi/gdb701.exp: mi runto main +PASS: gdb.mi/gdb701.exp: step over "foo = 0" +PASS: gdb.mi/gdb701.exp: create fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr.x +PASS: gdb.mi/gdb701.exp: list children of fooPtr.y +PASS: gdb.mi/gdb701.exp: list children of fooPtr.z +Running ./gdb.mi/gdb792.exp ... +PASS: gdb.mi/gdb792.exp: breakpoint at main +PASS: gdb.mi/gdb792.exp: mi runto main +PASS: gdb.mi/gdb792.exp: create var for class A +PASS: gdb.mi/gdb792.exp: list children of class A +PASS: gdb.mi/gdb792.exp: list children of A.public +PASS: gdb.mi/gdb792.exp: list children of A.private +PASS: gdb.mi/gdb792.exp: list children of A.protected +PASS: gdb.mi/gdb792.exp: list children of A.protected.b +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.public +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.private +PASS: gdb.mi/gdb792.exp: create var for class C which has baseclass A +PASS: gdb.mi/gdb792.exp: list children of class C +Running ./gdb.mi/mi2-amd64-entry-value.exp ... +Running ./gdb.mi/mi2-prompt.exp ... +PASS: gdb.mi/mi2-prompt.exp: console set prompt +PASS: gdb.mi/mi2-prompt.exp: -break-list +PASS: gdb.mi/mi2-prompt.exp: set prompt (banana) +PASS: gdb.mi/mi2-prompt.exp: interpreter-exec mi -break-list +Running ./gdb.mi/mi2-var-child.exp ... +PASS: gdb.mi/mi2-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi2-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi2-var-child.exp: run to 237 (set breakpoint) +PASS: gdb.mi/mi2-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi2-var-child.exp: create local variable weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: is weird editable +PASS: gdb.mi/mi2-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi2-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi2-var-child.exp: delete var weird +PASS: gdb.mi/mi2-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi2-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi2-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi2-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: break in do_anonymous_type_tests +PASS: gdb.mi/mi2-var-child.exp: continue to do_anonymous_type_tests breakpoint +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for v +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3 +PASS: gdb.mi/mi2-var-child.exp: expression for v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous.b +Running ./gdb.mi/mi-async.exp ... +Running ./gdb.mi/mi-basics.exp ... +PASS: gdb.mi/mi-basics.exp: acceptance of MI operations +PASS: gdb.mi/mi-basics.exp: file-exec-and-symbols operation +PASS: gdb.mi/mi-basics.exp: file-exec-file operation +PASS: gdb.mi/mi-basics.exp: file-symbol-file operation +PASS: gdb.mi/mi-basics.exp: break-delete (all) operation +PASS: gdb.mi/mi-basics.exp: all breakpoints removed +PASS: gdb.mi/mi-basics.exp: environment-directory arg operation +PASS: gdb.mi/mi-basics.exp: environment-directory empty-string operation +PASS: gdb.mi/mi-basics.exp: environment-directory operation +PASS: gdb.mi/mi-basics.exp: environment-cd arg operation +PASS: gdb.mi/mi-basics.exp: environment-pwd operation +PASS: gdb.mi/mi-basics.exp: environment-path +PASS: gdb.mi/mi-basics.exp: environment-path no-args operation +PASS: gdb.mi/mi-basics.exp: environment-path dir1 dir2 operation +PASS: gdb.mi/mi-basics.exp: environment-path -r dir operation +PASS: gdb.mi/mi-basics.exp: environment-path -r operation +PASS: gdb.mi/mi-basics.exp: initial tty is mi_inferior_tty_name +PASS: gdb.mi/mi-basics.exp: set tty to /dev/pts/1 +PASS: gdb.mi/mi-basics.exp: tty was set correctly +PASS: gdb.mi/mi-basics.exp: set tty to the empty string +PASS: gdb.mi/mi-basics.exp: make sure tty is empty +PASS: gdb.mi/mi-basics.exp: set tty to mi_inferior_tty_name (the way it was) +PASS: gdb.mi/mi-basics.exp: verify tty is correct +Running ./gdb.mi/mi-break.exp ... +PASS: gdb.mi/mi-break.exp: break-insert -t operation +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-break.exp: list of breakpoints +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +KFAIL: gdb.mi/mi-break.exp: break-insert -r operation (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee2 (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp .*llee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: list of breakpoints (PRMS: mi/14270) +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +PASS: gdb.mi/mi-break.exp: insert breakpoint with ignore count at callme +PASS: gdb.mi/mi-break.exp: run to breakpoint with ignore count +PASS: gdb.mi/mi-break.exp: breakpoint at nonexistent function +PASS: gdb.mi/mi-break.exp: create varobj for function call +PASS: gdb.mi/mi-break.exp: update varobj for function call +PASS: gdb.mi/mi-break.exp: test disabled creation +PASS: gdb.mi/mi-break.exp: test disabled creation: cleanup +PASS: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: breakpoint commands: set commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are set +PASS: gdb.mi/mi-break.exp: breakpoint commands: clear commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are cleared +ERROR: couldn't load /var/tmp/portage/cross-i686-pc-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.mi/mi-break into /var/tmp/portage/cross-i686-pc-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb (timed out). +UNRESOLVED: gdb.mi/mi-break.exp: breakpoint at main +PASS: gdb.mi/mi-break.exp: mi runto main +PASS: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2, again +PASS: gdb.mi/mi-break.exp: breakpoint commands: set commands +PASS: gdb.mi/mi-break.exp: intermediate stop and continue +PASS: gdb.mi/mi-break.exp: test hitting breakpoint with commands +PASS: gdb.mi/mi-break.exp: create local variable tpnum +PASS: gdb.mi/mi-break.exp: eval tpnum before tracepoint +PASS: gdb.mi/mi-break.exp: break-insert -a operation +PASS: gdb.mi/mi-break.exp: update tpnum +PASS: gdb.mi/mi-break.exp: eval tpnum after tracepoint +Running ./gdb.mi/mi-breakpoint-changed.exp ... +PASS: gdb.mi/mi-breakpoint-changed.exp: breakpoint at main +FAIL: gdb.mi/mi-breakpoint-changed.exp: mi runto main (unknown output after running) +PASS: gdb.mi/mi-breakpoint-changed.exp: change command +PASS: gdb.mi/mi-breakpoint-changed.exp: watch watch +PASS: gdb.mi/mi-breakpoint-changed.exp: trace marker +PASS: gdb.mi/mi-breakpoint-changed.exp: catch syscall +PASS: gdb.mi/mi-breakpoint-changed.exp: dprintf marker, "arg" " +PASS: gdb.mi/mi-breakpoint-changed.exp: condition 2 main > 0x0 +PASS: gdb.mi/mi-breakpoint-changed.exp: disable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: enable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: ignore 5 1 +PASS: gdb.mi/mi-breakpoint-changed.exp: passcount 1 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 5 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 6 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc1 resolved +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc1 resolved: hit_count is updated +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to pendfunc1 breakpoint +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: delete breakpoint on pendfunc1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on marker +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc3 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 resolved +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 2 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 pending again +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: +Running ./gdb.mi/mi-catch-load.exp ... +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-load: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-load: catch load +FAIL: gdb.mi/mi-catch-load.exp: catch-load: solib-event stop +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-unload: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-unload: catch unload +FAIL: gdb.mi/mi-catch-load.exp: catch-unload: solib-event stop +Running ./gdb.mi/mi-cli.exp ... +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with no arguments +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with one argument +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with bogus interpreter +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console bogus +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "file $binfile" +PASS: gdb.mi/mi-cli.exp: breakpoint at main +PASS: gdb.mi/mi-cli.exp: mi runto main +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set args foobar" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "show args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "break callee4" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "info break" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set listsize 1" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" +PASS: gdb.mi/mi-cli.exp: continue to callee4 +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "delete 2" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "up" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "down" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "frame 2" +PASS: gdb.mi/mi-cli.exp: -stack-select-frame 0 +PASS: gdb.mi/mi-cli.exp: check *stopped from CLI command +PASS: gdb.mi/mi-cli.exp: -break-insert -t basics.c:$line_main_hello +PASS: gdb.mi/mi-cli.exp: -exec-continue to line $line_main_hello +PASS: gdb.mi/mi-cli.exp: 34 next: run +PASS: gdb.mi/mi-cli.exp: 34 next: stop +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" at basics.c:$line_main_return +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "help set args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set $pc=0x0" +Running ./gdb.mi/mi-cmd-param-changed.exp ... +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: breakpoint at main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: mi runto main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" no event (requested by MI) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" no event (requested by MI interp) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking stepr" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set ch type on" +Running ./gdb.mi/mi-console.exp ... +PASS: gdb.mi/mi-console.exp: breakpoint at main +PASS: gdb.mi/mi-console.exp: mi runto main +PASS: gdb.mi/mi-console.exp: Testing console output +UNSUPPORTED: gdb.mi/mi-console.exp: Testing console output inferior output +PASS: gdb.mi/mi-console.exp: finished step over hello +Running ./gdb.mi/mi-disassemble.exp ... +PASS: gdb.mi/mi-disassemble.exp: breakpoint at main +PASS: gdb.mi/mi-disassemble.exp: mi runto main +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus filename +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus address +PASS: gdb.mi/mi-disassemble.exp: data-disassemble mix different args +PASS: gdb.mi/mi-disassemble.exp: data-disassemble wrong mode arg +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly mixed +Running ./gdb.mi/mi-eval.exp ... +PASS: gdb.mi/mi-eval.exp: breakpoint at callee4 +PASS: gdb.mi/mi-eval.exp: mi runto callee4 +PASS: gdb.mi/mi-eval.exp: next at callee4 +PASS: gdb.mi/mi-eval.exp: eval A +PASS: gdb.mi/mi-eval.exp: eval &A +PASS: gdb.mi/mi-eval.exp: eval A+3 +PASS: gdb.mi/mi-eval.exp: eval A + 3 +Running ./gdb.mi/mi-file.exp ... +PASS: gdb.mi/mi-file.exp: request path info of current source file (basics.c) +PASS: gdb.mi/mi-file.exp: Getting a list of source files. +Running ./gdb.mi/mi-file-transfer.exp ... +FAIL: gdb.mi/mi-file-transfer.exp: put binary file +FAIL: gdb.mi/mi-file-transfer.exp: get binary file +FAIL: gdb.mi/mi-file-transfer.exp: compare binary file +FAIL: gdb.mi/mi-file-transfer.exp: deleted binary file +Running ./gdb.mi/mi-fill-memory.exp ... +PASS: gdb.mi/mi-fill-memory.exp: breakpoint at main +PASS: gdb.mi/mi-fill-memory.exp: mi runto main +PASS: gdb.mi/mi-fill-memory.exp: next at main +PASS: gdb.mi/mi-fill-memory.exp: no arguments +PASS: gdb.mi/mi-fill-memory.exp: one argument missing +PASS: gdb.mi/mi-fill-memory.exp: memory successfully written +PASS: gdb.mi/mi-fill-memory.exp: memory successfully filled (8 bytes) +PASS: gdb.mi/mi-fill-memory.exp: pattern correctly read from memory +Running ./gdb.mi/mi-fullname-deleted.exp ... +PASS: gdb.mi/mi-fullname-deleted.exp: set substitute-path +PASS: gdb.mi/mi-fullname-deleted.exp: fullname present +PASS: gdb.mi/mi-fullname-deleted.exp: substituted fullname +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does not match +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does match +Running ./gdb.mi/mi-hack-cli.exp ... +PASS: gdb.mi/mi-hack-cli.exp: show architecture +PASS: gdb.mi/mi-hack-cli.exp: 47show architecture +Running ./gdb.mi/mi-info-os.exp ... +FAIL: gdb.mi/mi-info-os.exp: -info-os +Running ./gdb.mi/mi-inheritance-syntax-error.exp ... +PASS: gdb.mi/mi-inheritance-syntax-error.exp: breakpoint at C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: mi runto C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: create var for THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: list children of THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -var-info-path-expression var1.A +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -data-evaluate-expression (*(class A*) this) +Running ./gdb.mi/mi-logging.exp ... +PASS: gdb.mi/mi-logging.exp: breakpoint at main +PASS: gdb.mi/mi-logging.exp: mi runto main +PASS: gdb.mi/mi-logging.exp: logging on +PASS: gdb.mi/mi-logging.exp: logged step +PASS: gdb.mi/mi-logging.exp: logged next +PASS: gdb.mi/mi-logging.exp: logging off +PASS: gdb.mi/mi-logging.exp: Log file contents +PASS: gdb.mi/mi-logging.exp: redirect logging on +PASS: gdb.mi/mi-logging.exp: redirect logging off +PASS: gdb.mi/mi-logging.exp: Redirect log file contents +Running ./gdb.mi/mi-memory-changed.exp ... +PASS: gdb.mi/mi-memory-changed.exp: insert breakpoint +PASS: gdb.mi/mi-memory-changed.exp: continue to callee4 +PASS: gdb.mi/mi-memory-changed.exp: set var C = 4 +PASS: gdb.mi/mi-memory-changed.exp: create objvar for C +PASS: gdb.mi/mi-memory-changed.exp: change C thru. varobj +PASS: gdb.mi/mi-memory-changed.exp: change C thru. -data-write-memory-bytes +PASS: gdb.mi/mi-memory-changed.exp: get address of main +Running ./gdb.mi/mi-nonstop-exit.exp ... +PASS: gdb.mi/mi-nonstop-exit.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue (2) +Running ./gdb.mi/mi-nonstop.exp ... +PASS: gdb.mi/mi-nonstop.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop.exp: mi runto main +PASS: gdb.mi/mi-nonstop.exp: breakpoint at marker +PASS: gdb.mi/mi-nonstop.exp: w0,i0 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i0 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 1 +PASS: gdb.mi/mi-nonstop.exp: select thread 2 +PASS: gdb.mi/mi-nonstop.exp: create varobj in first thread +PASS: gdb.mi/mi-nonstop.exp: select thread 3 +PASS: gdb.mi/mi-nonstop.exp: create varobj in second thread +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 2 +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 2 +PASS: gdb.mi/mi-nonstop.exp: w1,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 3 +PASS: gdb.mi/mi-nonstop.exp: update varobj, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w0, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: interrupted +PASS: gdb.mi/mi-nonstop.exp: got interrupt +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 4 +PASS: gdb.mi/mi-nonstop.exp: resume all +PASS: gdb.mi/mi-nonstop.exp: w0,i2 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i2 stop +PASS: gdb.mi/mi-nonstop.exp: set condition, 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i3 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop on cond breakpoint +PASS: gdb.mi/mi-nonstop.exp: update varobj, 2 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: stacktrace of running thread +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +PASS: gdb.mi/mi-nonstop.exp: select first worker thread +PASS: gdb.mi/mi-nonstop.exp: ask the second thread to exit +UNSUPPORTED: gdb.mi/mi-nonstop.exp: wait for thread exit +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +Running ./gdb.mi/mi-nsintrall.exp ... +PASS: gdb.mi/mi-nsintrall.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at main +PASS: gdb.mi/mi-nsintrall.exp: mi runto main +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsintrall.exp: stop 0 +PASS: gdb.mi/mi-nsintrall.exp: stop 1 +PASS: gdb.mi/mi-nsintrall.exp: stop 2 +PASS: gdb.mi/mi-nsintrall.exp: stop 3 +PASS: gdb.mi/mi-nsintrall.exp: stop 4 +PASS: gdb.mi/mi-nsintrall.exp: stop 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all stopped +PASS: gdb.mi/mi-nsintrall.exp: resume all, no breakpoint +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all +PASS: gdb.mi/mi-nsintrall.exp: interrupt all threads +PASS: gdb.mi/mi-nsintrall.exp: interrupt 0 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 1 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 2 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 3 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 4 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all interrupted +PASS: gdb.mi/mi-nsintrall.exp: resume all after interrupting +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all after interrupting +Running ./gdb.mi/mi-nsmoribund.exp ... +PASS: gdb.mi/mi-nsmoribund.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at main +PASS: gdb.mi/mi-nsmoribund.exp: mi runto main +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: stop 0 +PASS: gdb.mi/mi-nsmoribund.exp: stop 1 +PASS: gdb.mi/mi-nsmoribund.exp: stop 2 +PASS: gdb.mi/mi-nsmoribund.exp: stop 3 +PASS: gdb.mi/mi-nsmoribund.exp: stop 4 +PASS: gdb.mi/mi-nsmoribund.exp: stop 5 +PASS: gdb.mi/mi-nsmoribund.exp: stop 6 +PASS: gdb.mi/mi-nsmoribund.exp: stop 7 +PASS: gdb.mi/mi-nsmoribund.exp: stop 8 +PASS: gdb.mi/mi-nsmoribund.exp: stop 9 +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all stopped except the main thread +PASS: gdb.mi/mi-nsmoribund.exp: select thread 5 +PASS: gdb.mi/mi-nsmoribund.exp: thread specific breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: resume all, thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: hit thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all running except the breakpoint thread +PASS: gdb.mi/mi-nsmoribund.exp: resume all, program exited normally +Running ./gdb.mi/mi-ns-stale-regcache.exp ... +PASS: gdb.mi/mi-ns-stale-regcache.exp: breakpoint at main +PASS: gdb.mi/mi-ns-stale-regcache.exp: mi runto main +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale register cache of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale frame info of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: main thread still running +Running ./gdb.mi/mi-nsthrexec.exp ... +Running ./gdb.mi/mi-pending.exp ... +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on pendfunc1 +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on mi-pendshr.c:pendfunc2 if x==4 +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 a second time +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc2 with x==4 +Running ./gdb.mi/mi-pthreads.exp ... +PASS: gdb.mi/mi-pthreads.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-pthreads.exp: breakpoint at done_making_threads +PASS: gdb.mi/mi-pthreads.exp: mi runto done_making_threads +PASS: gdb.mi/mi-pthreads.exp: -thread_list_ids (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: finding threads in MI output (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 123456789 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 6 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 5 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 4 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 3 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 2 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 1 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 6 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 5 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 4 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 3 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 2 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 1 +Running ./gdb.mi/mi-read-memory.exp ... +PASS: gdb.mi/mi-read-memory.exp: breakpoint at main +PASS: gdb.mi/mi-read-memory.exp: mi runto main +PASS: gdb.mi/mi-read-memory.exp: next at main +PASS: gdb.mi/mi-read-memory.exp: no arguments +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte offset by -6 +PASS: gdb.mi/mi-read-memory.exp: expression in quotes +PASS: gdb.mi/mi-read-memory.exp: ascii and data +PASS: gdb.mi/mi-read-memory.exp: decimal +PASS: gdb.mi/mi-read-memory.exp: octal +Running ./gdb.mi/mi-record-changed.exp ... +Running ./gdb.mi/mi-regs.exp ... +Running ./gdb.mi/mi-return.exp ... +PASS: gdb.mi/mi-return.exp: breakpoint at callee4 +PASS: gdb.mi/mi-return.exp: mi runto callee4 +PASS: gdb.mi/mi-return.exp: delete all breakpoints +PASS: gdb.mi/mi-return.exp: return from callee4 now +Running ./gdb.mi/mi-reverse.exp ... +Running ./gdb.mi/mi-simplerun.exp ... +PASS: gdb.mi/mi-simplerun.exp: break-insert operation +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints +PASS: gdb.mi/mi-simplerun.exp: disabling of breakpoints +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints, 16 disabled +PASS: gdb.mi/mi-simplerun.exp: run to main +PASS: gdb.mi/mi-simplerun.exp: next at main +PASS: gdb.mi/mi-simplerun.exp: step at main +PASS: gdb.mi/mi-simplerun.exp: step to callee4 +PASS: gdb.mi/mi-simplerun.exp: exec-finish +PASS: gdb.mi/mi-simplerun.exp: continue to end +Running ./gdb.mi/mi-solib.exp ... +PASS: gdb.mi/mi-solib.exp: set stop-on-solib-events +PASS: gdb.mi/mi-solib.exp: check for solib event +Running ./gdb.mi/mi-stack.exp ... +PASS: gdb.mi/mi-stack.exp: breakpoint at callee4 +PASS: gdb.mi/mi-stack.exp: mi runto callee4 +PASS: gdb.mi/mi-stack.exp: stack frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 1 +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 3 +PASS: gdb.mi/mi-stack.exp: stack frame listing wrong +PASS: gdb.mi/mi-stack.exp: selected frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 300 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing wrong +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 300 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names +PASS: gdb.mi/mi-stack.exp: next's in callee4 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names and values +PASS: gdb.mi/mi-stack.exp: stack locals listing, simple types: names and values, complex type: names and types +PASS: gdb.mi/mi-stack.exp: stack locals listing wrong +PASS: gdb.mi/mi-stack.exp: stack select frame 1 +PASS: gdb.mi/mi-stack.exp: stack locals listing for new frame +PASS: gdb.mi/mi-stack.exp: stack locals for same frame (level 1) +PASS: gdb.mi/mi-stack.exp: stack info-depth +PASS: gdb.mi/mi-stack.exp: stack info-depth 3 +PASS: gdb.mi/mi-stack.exp: stack info-depth 99 +PASS: gdb.mi/mi-stack.exp: stack info-depth wrong usage +Running ./gdb.mi/mi-stepi.exp ... +PASS: gdb.mi/mi-stepi.exp: breakpoint at main +PASS: gdb.mi/mi-stepi.exp: mi runto main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main +PASS: gdb.mi/mi-stepi.exp: next-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 (line check) +Running ./gdb.mi/mi-stepn.exp ... +PASS: gdb.mi/mi-stepn.exp: breakpoint at main +PASS: gdb.mi/mi-stepn.exp: mi runto main +PASS: gdb.mi/mi-stepn.exp: breakpoint at do_nothing +PASS: gdb.mi/mi-stepn.exp: breakpoint-hit reported +Running ./gdb.mi/mi-syn-frame.exp ... +PASS: gdb.mi/mi-syn-frame.exp: breakpoint at main +PASS: gdb.mi/mi-syn-frame.exp: mi runto main +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint foo +PASS: gdb.mi/mi-syn-frame.exp: call inferior's function with a breakpoint set in it +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function stopped at bp, showing gdb dummy frame +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint subroutine +PASS: gdb.mi/mi-syn-frame.exp: data evaluate expression +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: call inferior function which raises exception +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function at exception +Running ./gdb.mi/mi-until.exp ... +PASS: gdb.mi/mi-until.exp: break-insert operation +PASS: gdb.mi/mi-until.exp: run to main +PASS: gdb.mi/mi-until.exp: break-delete 1 +KFAIL: gdb.mi/mi-until.exp: until after while loop (stopped at wrong place) (PRMS: gdb/2104) +PASS: gdb.mi/mi-until.exp: until line number +PASS: gdb.mi/mi-until.exp: until line number:file +PASS: gdb.mi/mi-until.exp: until after current function +Running ./gdb.mi/mi-var-block.exp ... +PASS: gdb.mi/mi-var-block.exp: breakpoint at do_block_tests +PASS: gdb.mi/mi-var-block.exp: mi runto do_block_tests +PASS: gdb.mi/mi-var-block.exp: create local variable cb +PASS: gdb.mi/mi-var-block.exp: try to create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 1 +PASS: gdb.mi/mi-var-block.exp: delete var foo 1 +PASS: gdb.mi/mi-var-block.exp: create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 2 +PASS: gdb.mi/mi-var-block.exp: update all vars: cb foo changed +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 3 +PASS: gdb.mi/mi-var-block.exp: create local variable inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 4 +PASS: gdb.mi/mi-var-block.exp: create local variable foo2 +XFAIL: gdb.mi/mi-var-block.exp: update inner_foo: should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: evaluate inner_foo: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update foo: did not change +PASS: gdb.mi/mi-var-block.exp: delete var inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 5 +XFAIL: gdb.mi/mi-var-block.exp: update foo2: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 6 +XFAIL: gdb.mi/mi-var-block.exp: update foo2 should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: update foo should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update cb +PASS: gdb.mi/mi-var-block.exp: delete var foo 2 +PASS: gdb.mi/mi-var-block.exp: delete var foo2 +PASS: gdb.mi/mi-var-block.exp: delete var cb +Running ./gdb.mi/mi-var-child.exp ... +PASS: gdb.mi/mi-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi-var-child.exp: run to 215 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi-var-child.exp: create local variable weird +PASS: gdb.mi/mi-var-child.exp: get children of weird +PASS: gdb.mi/mi-var-child.exp: get number of children of weird +PASS: gdb.mi/mi-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: is weird editable +PASS: gdb.mi/mi-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi-var-child.exp: delete var weird +PASS: gdb.mi/mi-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.10 changed, don't print values. +PASS: gdb.mi/mi-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.11 changed, print values. +PASS: gdb.mi/mi-var-child.exp: listing of names and values of children +PASS: gdb.mi/mi-var-child.exp: listing of children, simple types: names, type and values, complex types: names and types +PASS: gdb.mi/mi-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: run to mi-var-child.c:323 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create varobj for s +PASS: gdb.mi/mi-var-child.exp: list children of S +PASS: gdb.mi/mi-var-child.exp: delete S.a +PASS: gdb.mi/mi-var-child.exp: delete S.b +PASS: gdb.mi/mi-var-child.exp: delete S +Running ./gdb.mi/mi-var-child-f.exp ... +UNSUPPORTED: gdb.mi/mi-var-child-f.exp: compilation array.f +Running ./gdb.mi/mi-var-cmd.exp ... +PASS: gdb.mi/mi-var-cmd.exp: create global variable +PASS: gdb.mi/mi-var-cmd.exp: create non-existent variable +PASS: gdb.mi/mi-var-cmd.exp: create out of scope variable +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: run to 148 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create local variable linteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpinteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable llong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lplong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable ldouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpdouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable func +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: create lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: create int +PASS: gdb.mi/mi-var-cmd.exp: update all vars +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_test +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (2) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (3) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (4) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (5) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: many changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (6) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: func and lpsimple changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (7) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lsimple and others changed +PASS: gdb.mi/mi-var-cmd.exp: assign to global_simple +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger again, same value +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger not changed after same assign +PASS: gdb.mi/mi-var-cmd.exp: eval linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: update all vars: no changes on second update +PASS: gdb.mi/mi-var-cmd.exp: eval lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lcharacter +PASS: gdb.mi/mi-var-cmd.exp: eval lcharacter +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: eval llong +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: eval lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: eval lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lpfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to ldouble +PASS: gdb.mi/mi-var-cmd.exp: assign to func +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: var update +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func (update) +PASS: gdb.mi/mi-var-cmd.exp: create global variable array_ptr +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: mi runto subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: create i +PASS: gdb.mi/mi-var-cmd.exp: create l +PASS: gdb.mi/mi-var-cmd.exp: create linteger +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 +XFAIL: gdb.mi/mi-var-cmd.exp: update all vars: changed FIXME +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 (2) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: i changed +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 (3) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: llong changed +PASS: gdb.mi/mi-var-cmd.exp: next out of subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: update all vars: all now out of scope +PASS: gdb.mi/mi-var-cmd.exp: delete var +PASS: gdb.mi/mi-var-cmd.exp: delete var linteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lpinteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var llong +PASS: gdb.mi/mi-var-cmd.exp: delete var lplong +PASS: gdb.mi/mi-var-cmd.exp: delete var lfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var lpfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var ldouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lpdouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var lpsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var func +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: delete var i +PASS: gdb.mi/mi-var-cmd.exp: delete var l +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: create selected_a +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-cmd.exp: mi runto incr_a +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in incr_a +PASS: gdb.mi/mi-var-cmd.exp: step a line in incr_a +PASS: gdb.mi/mi-var-cmd.exp: return from incr_a to do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: floating varobj invalidation +PASS: gdb.mi/mi-var-cmd.exp: delete selected_a +PASS: gdb.mi/mi-var-cmd.exp: delete array_ptr +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:351 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create varobj for v1 +PASS: gdb.mi/mi-var-cmd.exp: create varobj for v2 +PASS: gdb.mi/mi-var-cmd.exp: list children of v1 +PASS: gdb.mi/mi-var-cmd.exp: list children of v1.nested +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 1 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 2 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 3 +PASS: gdb.mi/mi-var-cmd.exp: check V2: 4 +PASS: gdb.mi/mi-var-cmd.exp: update varobjs: V2 changed +PASS: gdb.mi/mi-var-cmd.exp: -var-set-frozen V2 1 +PASS: gdb.mi/mi-var-cmd.exp: update varobjs: nothing changed +PASS: gdb.mi/mi-var-cmd.exp: check V2: 5 +PASS: gdb.mi/mi-var-cmd.exp: update V2 explicitly +PASS: gdb.mi/mi-var-cmd.exp: check V2: 6 +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:385 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: -var-set-frozen V1 1 +PASS: gdb.mi/mi-var-cmd.exp: update varobjs: nothing changed +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 1 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 2 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 3 +PASS: gdb.mi/mi-var-cmd.exp: update V1.nested.j +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 1 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 8 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 3 +PASS: gdb.mi/mi-var-cmd.exp: update V1.nested +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 1 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 8 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 9 +PASS: gdb.mi/mi-var-cmd.exp: update V1.i +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 7 +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:410 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: -var-set-frozen V1 0 +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 7 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 8 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 9 +PASS: gdb.mi/mi-var-cmd.exp: update V1 +PASS: gdb.mi/mi-var-cmd.exp: check V1.i: 10 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.j: 11 +PASS: gdb.mi/mi-var-cmd.exp: check V1.nested.k: 12 +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:510 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create varobj for Data +PASS: gdb.mi/mi-var-cmd.exp: list children of Data +PASS: gdb.mi/mi-var-cmd.exp: access bitfield +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:453 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create floating varobj +PASS: gdb.mi/mi-var-cmd.exp: update F (1) +PASS: gdb.mi/mi-var-cmd.exp: check F (1) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:464 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (2) +PASS: gdb.mi/mi-var-cmd.exp: check F (2) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:472 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (--all-values) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:478 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (3) +PASS: gdb.mi/mi-var-cmd.exp: check F (3) +PASS: gdb.mi/mi-var-cmd.exp: inside breakpoint inside callee +PASS: gdb.mi/mi-var-cmd.exp: continue to where i is initialized +PASS: gdb.mi/mi-var-cmd.exp: update F inside callee +PASS: gdb.mi/mi-var-cmd.exp: check F inside callee +PASS: gdb.mi/mi-var-cmd.exp: create null_ptr +PASS: gdb.mi/mi-var-cmd.exp: update null_ptr +PASS: gdb.mi/mi-var-cmd.exp: delete null_ptr +PASS: gdb.mi/mi-var-cmd.exp: kill program before endvar +PASS: gdb.mi/mi-var-cmd.exp: create endvar +PASS: gdb.mi/mi-var-cmd.exp: update endvar +PASS: gdb.mi/mi-var-cmd.exp: delete endvar +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: create varobj +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: check initial value +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at main +PASS: gdb.mi/mi-var-cmd.exp: mi runto main +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now, not changed +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now, not changed +Running ./gdb.mi/mi-var-cp.exp ... +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:20 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rx +PASS: gdb.mi/mi-var-cp.exp: update RX (1) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 167 +PASS: gdb.mi/mi-var-cp.exp: update RX (2) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 567 +PASS: gdb.mi/mi-var-cp.exp: update RX (3) +PASS: gdb.mi/mi-var-cp.exp: delete RX +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:46 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s.public +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.i +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.j +PASS: gdb.mi/mi-var-cp.exp: delete S2 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:82 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rptr_s +PASS: gdb.mi/mi-var-cp.exp: list public child of RPTR +PASS: gdb.mi/mi-var-cp.exp: list children of reference to pointer +PASS: gdb.mi/mi-var-cp.exp: check i member +PASS: gdb.mi/mi-var-cp.exp: check j member +PASS: gdb.mi/mi-var-cp.exp: delete RPTR +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:105 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: check attributes of S +PASS: gdb.mi/mi-var-cp.exp: check attributes of R +PASS: gdb.mi/mi-var-cp.exp: -var-update should not list structure varobjs +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:145 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for ip +PASS: gdb.mi/mi-var-cp.exp: list children of IP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression IP.*ip +PASS: gdb.mi/mi-var-cp.exp: create varobj for dp +PASS: gdb.mi/mi-var-cp.exp: list children of DP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public.i +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1.public.i +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public +PASS: gdb.mi/mi-var-cp.exp: create varobj for d +PASS: gdb.mi/mi-var-cp.exp: list children of D +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression D.Base1 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:192 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for array +PASS: gdb.mi/mi-var-cp.exp: list children of A +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression A.2 +PASS: gdb.mi/mi-var-cp.exp: break in anonymous_structs_and_unions +PASS: gdb.mi/mi-var-cp.exp: continue to anonymous_structs breakpoint +PASS: gdb.mi/mi-var-cp.exp: VT: create root varobj for a +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1 +PASS: gdb.mi/mi-var-cp.exp: path expression for a1 +PASS: gdb.mi/mi-var-cp.exp: expression for a1 +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +Running ./gdb.mi/mi-var-create-rtti.exp ... +PASS: gdb.mi/mi-var-create-rtti.exp: breakpoint at main +PASS: gdb.mi/mi-var-create-rtti.exp: mi runto main +PASS: gdb.mi/mi-var-create-rtti.exp: -var-create sp1 * $sp +Running ./gdb.mi/mi-var-display.exp ... +PASS: gdb.mi/mi-var-display.exp: break-insert operation +PASS: gdb.mi/mi-var-display.exp: run to main +PASS: gdb.mi/mi-var-display.exp: create local variable bar +PASS: gdb.mi/mi-var-display.exp: info type variable bar +PASS: gdb.mi/mi-var-display.exp: show format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new format +PASS: gdb.mi/mi-var-display.exp: assing to variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new value +PASS: gdb.mi/mi-var-display.exp: delete var bar +PASS: gdb.mi/mi-var-display.exp: create local variable foo +PASS: gdb.mi/mi-var-display.exp: info type variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: assing to variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo in hex +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in hex +PASS: gdb.mi/mi-var-display.exp: eval variable foo in octal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in octal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in decimal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in decimal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in natural +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in natural +PASS: gdb.mi/mi-var-display.exp: eval variable foo in binary +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in binary +PASS: gdb.mi/mi-var-display.exp: delete var foo +PASS: gdb.mi/mi-var-display.exp: create local variable weird +PASS: gdb.mi/mi-var-display.exp: get children local variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.integer +PASS: gdb.mi/mi-var-display.exp: set format variable weird.character +PASS: gdb.mi/mi-var-display.exp: set format variable weird.char_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_int +PASS: gdb.mi/mi-var-display.exp: set format variable weird.int_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_array +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_struct +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.u1 +PASS: gdb.mi/mi-var-display.exp: set format variable weird.s2 +PASS: gdb.mi/mi-var-display.exp: delete var weird +PASS: gdb.mi/mi-var-display.exp: break-insert operation 2 +PASS: gdb.mi/mi-var-display.exp: continue to do_special_tests +PASS: gdb.mi/mi-var-display.exp: create local variable u +PASS: gdb.mi/mi-var-display.exp: eval variable u +PASS: gdb.mi/mi-var-display.exp: info type variable u +PASS: gdb.mi/mi-var-display.exp: is u editable +PASS: gdb.mi/mi-var-display.exp: get number of children of u +PASS: gdb.mi/mi-var-display.exp: get children of u +PASS: gdb.mi/mi-var-display.exp: create local variable anonu +PASS: gdb.mi/mi-var-display.exp: eval variable anonu +PASS: gdb.mi/mi-var-display.exp: info type variable anonu +PASS: gdb.mi/mi-var-display.exp: is anonu editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anonu +PASS: gdb.mi/mi-var-display.exp: get children of anonu +PASS: gdb.mi/mi-var-display.exp: create local variable s +PASS: gdb.mi/mi-var-display.exp: eval variable s +PASS: gdb.mi/mi-var-display.exp: info type variable s +PASS: gdb.mi/mi-var-display.exp: is s editable +PASS: gdb.mi/mi-var-display.exp: get number of children of s +PASS: gdb.mi/mi-var-display.exp: get children of s +PASS: gdb.mi/mi-var-display.exp: create local variable anons +PASS: gdb.mi/mi-var-display.exp: eval variable anons +PASS: gdb.mi/mi-var-display.exp: info type variable anons +PASS: gdb.mi/mi-var-display.exp: is anons editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anons +PASS: gdb.mi/mi-var-display.exp: get children of anons +PASS: gdb.mi/mi-var-display.exp: create local variable e +PASS: gdb.mi/mi-var-display.exp: eval variable e +PASS: gdb.mi/mi-var-display.exp: info type variable e +PASS: gdb.mi/mi-var-display.exp: is e editable +PASS: gdb.mi/mi-var-display.exp: get number of children of e +PASS: gdb.mi/mi-var-display.exp: get children of e +PASS: gdb.mi/mi-var-display.exp: create local variable anone +PASS: gdb.mi/mi-var-display.exp: eval variable anone +PASS: gdb.mi/mi-var-display.exp: create duplicate local variable anone +PASS: gdb.mi/mi-var-display.exp: info type variable anone +PASS: gdb.mi/mi-var-display.exp: is anone editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anone +PASS: gdb.mi/mi-var-display.exp: get children of anone +PASS: gdb.mi/mi-var-display.exp: print FP register +PASS: gdb.mi/mi-var-display.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-display.exp: mi runto incr_a +PASS: gdb.mi/mi-var-display.exp: create local variable a1 +PASS: gdb.mi/mi-var-display.exp: create variable a2 in different scope +Running ./gdb.mi/mi-var-invalidate.exp ... +PASS: gdb.mi/mi-var-invalidate.exp: create global variable +PASS: gdb.mi/mi-var-invalidate.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: create local variable linteger +PASS: gdb.mi/mi-var-invalidate.exp: create floating variable +PASS: gdb.mi/mi-var-invalidate.exp: breakpoint at main +PASS: gdb.mi/mi-var-invalidate.exp: mi runto main +PASS: gdb.mi/mi-var-invalidate.exp: set format variable float_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (1) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple still alive +PASS: gdb.mi/mi-var-invalidate.exp: type simpleton for valid variable global_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not valid anymore due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (2) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable global_simple +Running ./gdb.mi/mi-var-rtti.exp ... +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:37 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:64 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:94 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:149 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:202 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.First (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:245 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:269 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:281 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:299 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:323 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:335 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in skip_type_update_when_not_use_rtti +Running ./gdb.mi/mi-watch.exp ... +PASS: gdb.mi/mi-watch.exp: hw watchpoints toggle (1) +PASS: gdb.mi/mi-watch.exp: sw: breakpoint at callee4 +PASS: gdb.mi/mi-watch.exp: sw: mi runto callee4 +PASS: gdb.mi/mi-watch.exp: sw: break-watch operation +PASS: gdb.mi/mi-watch.exp: sw: list of watchpoints +PASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +XPASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +Running ./gdb.mi/mi-watch-nonstop.exp ... +Running ./gdb.mi/pr11022.exp ... +Running ./gdb.modula2/unbounded-array.exp ... +PASS: gdb.modula2/unbounded-array.exp: switch to modula-2 +PASS: gdb.modula2/unbounded-array.exp: print the last legal element of array a +PASS: gdb.modula2/unbounded-array.exp: print unbounded array contents +PASS: gdb.modula2/unbounded-array.exp: print the 1st element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 2nd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 3rd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 4th element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 5th element of array a +Running ./gdb.multi/base.exp ... +PASS: gdb.multi/base.exp: add empty inferior 2 +PASS: gdb.multi/base.exp: switch to inferior 2 +PASS: gdb.multi/base.exp: load hangout file in inferior 2 +PASS: gdb.multi/base.exp: add inferior 3 with -exec goodbye +PASS: gdb.multi/base.exp: info inferiors +PASS: gdb.multi/base.exp: info inferior 2 3 +PASS: gdb.multi/base.exp: info inferior 1-2 +PASS: gdb.multi/base.exp: switch to inferior 1 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 1 +PASS: gdb.multi/base.exp: switch to inferior 3 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 3 +PASS: gdb.multi/base.exp: switch back to inferior 1 +PASS: gdb.multi/base.exp: set listsize 1 +PASS: gdb.multi/base.exp: list commonfun in hello +PASS: gdb.multi/base.exp: print hglob +PASS: gdb.multi/base.exp: print glob (hello) +PASS: gdb.multi/base.exp: switch to inferior 3 to print globals +PASS: gdb.multi/base.exp: print gglob +PASS: gdb.multi/base.exp: print glob (goodbye) +PASS: gdb.multi/base.exp: list commonfun in goodbye +PASS: gdb.multi/base.exp: switch to inferior 1 to run it +PASS: gdb.multi/base.exp: break hello +PASS: gdb.multi/base.exp: continue +PASS: gdb.multi/base.exp: remove-inferiors 2-3 +PASS: gdb.multi/base.exp: check remove-inferiors +Running ./gdb.multi/bkpt-multi-exec.exp ... +Running ./gdb.multi/multi-arch-exec.exp ... +Running ./gdb.multi/multi-arch.exp ... +Running ./gdb.multi/watchpoint-multi.exp ... +UNTESTED: gdb.multi/watchpoint-multi.exp: watchpoint-multi.exp +Running ./gdb.objc/basicclass.exp ... +UNSUPPORTED: gdb.objc/basicclass.exp: Couldn't compile ./gdb.objc/basicclass.m: unrecognized error +Running ./gdb.objc/nondebug.exp ... +UNSUPPORTED: gdb.objc/nondebug.exp: Couldn't compile ./gdb.objc/nondebug.m: unrecognized error +Running ./gdb.objc/objcdecode.exp ... +UNSUPPORTED: gdb.objc/objcdecode.exp: Couldn't compile ./gdb.objc/objcdecode.m: unrecognized error +Running ./gdb.objc/print.exp ... +PASS: gdb.objc/print.exp: set language objective-c +PASS: gdb.objc/print.exp: set language to "objective-c" +PASS: gdb.objc/print.exp: check fp + text +PASS: gdb.objc/print.exp: p 1. +PASS: gdb.objc/print.exp: p 1.5 +PASS: gdb.objc/print.exp: p 1.f +PASS: gdb.objc/print.exp: p 1.5f +PASS: gdb.objc/print.exp: p 1.l +PASS: gdb.objc/print.exp: p 1.5l +PASS: gdb.objc/print.exp: p 0x1.1 +PASS: gdb.objc/print.exp: reject p 1.1x +PASS: gdb.objc/print.exp: reject p 1.1ff +PASS: gdb.objc/print.exp: reject p 1.1ll +Running ./gdb.opencl/callfuncs.exp ... +Running ./gdb.opencl/convs_casts.exp ... +Running ./gdb.opencl/datatypes.exp ... +Running ./gdb.opencl/operators.exp ... +Running ./gdb.opencl/vec_comps.exp ... +Running ./gdb.opt/clobbered-registers-O2.exp ... +PASS: gdb.opt/clobbered-registers-O2.exp: Backtracing +PASS: gdb.opt/clobbered-registers-O2.exp: print operand0 +PASS: gdb.opt/clobbered-registers-O2.exp: print operand1 +Running ./gdb.opt/inline-break.exp ... +PASS: gdb.opt/inline-break.exp: break func1 +PASS: gdb.opt/inline-break.exp: break func2 +PASS: gdb.opt/inline-break.exp: break func3b +PASS: gdb.opt/inline-break.exp: break func4b +PASS: gdb.opt/inline-break.exp: break func5b +PASS: gdb.opt/inline-break.exp: break func6b +PASS: gdb.opt/inline-break.exp: break func7b +PASS: gdb.opt/inline-break.exp: break func8b +PASS: gdb.opt/inline-break.exp: print func1 +PASS: gdb.opt/inline-break.exp: print func2 +Running ./gdb.opt/inline-bt.exp ... +PASS: gdb.opt/inline-bt.exp: continue to bar (1) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (1) +PASS: gdb.opt/inline-bt.exp: bar not inlined +PASS: gdb.opt/inline-bt.exp: continue to bar (2) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (2) +PASS: gdb.opt/inline-bt.exp: up from bar (2) +PASS: gdb.opt/inline-bt.exp: func1 inlined (2) +PASS: gdb.opt/inline-bt.exp: continue to bar (3) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (3) +PASS: gdb.opt/inline-bt.exp: up from bar (3) +PASS: gdb.opt/inline-bt.exp: func1 inlined (3) +PASS: gdb.opt/inline-bt.exp: up from func1 (3) +PASS: gdb.opt/inline-bt.exp: func2 inlined (3) +Running ./gdb.opt/inline-cmds.exp ... +PASS: gdb.opt/inline-cmds.exp: set listsize 1 +PASS: gdb.opt/inline-cmds.exp: continue to bar (1) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (1) +PASS: gdb.opt/inline-cmds.exp: up from bar (1) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (1) +PASS: gdb.opt/inline-cmds.exp: continue to bar (2) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (2) +PASS: gdb.opt/inline-cmds.exp: up from bar (2) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (2) +PASS: gdb.opt/inline-cmds.exp: up from func1 (2) +PASS: gdb.opt/inline-cmds.exp: func2 inlined (2) +PASS: gdb.opt/inline-cmds.exp: continue to marker +PASS: gdb.opt/inline-cmds.exp: backtrace from marker +PASS: gdb.opt/inline-cmds.exp: marker not inlined +PASS: gdb.opt/inline-cmds.exp: next over inlined functions +PASS: gdb.opt/inline-cmds.exp: next past inlined func1 +PASS: gdb.opt/inline-cmds.exp: print x before func1 +PASS: gdb.opt/inline-cmds.exp: backtrace does not include func1 +PASS: gdb.opt/inline-cmds.exp: stepped over call to func1 +PASS: gdb.opt/inline-cmds.exp: step into func1 +PASS: gdb.opt/inline-cmds.exp: finish from func1 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: consecutive func1 +PASS: gdb.opt/inline-cmds.exp: next to first func1 +KFAIL: gdb.opt/inline-cmds.exp: next to second func1 (PRMS: gdb/NNNN) +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: func1 then func3 +PASS: gdb.opt/inline-cmds.exp: next to func1 before func3 +PASS: gdb.opt/inline-cmds.exp: next to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: finish into func1 +PASS: gdb.opt/inline-cmds.exp: next to finish marker +PASS: gdb.opt/inline-cmds.exp: step into finish marker +PASS: gdb.opt/inline-cmds.exp: finish from marker to func1 +PASS: gdb.opt/inline-cmds.exp: step into func1 for finish +PASS: gdb.opt/inline-cmds.exp: finish from func1 to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: before the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach 1 the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at main of outer_inline +PASS: gdb.opt/inline-cmds.exp: enter outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline2 +PASS: gdb.opt/inline-cmds.exp: enter outer_inline1 from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline1 +PASS: gdb.opt/inline-cmds.exp: enter noinline from outer_inline1 +PASS: gdb.opt/inline-cmds.exp: backtrace at noinline from outer_inline1 +PASS: gdb.opt/inline-cmds.exp: enter inlined_fn from noinline +PASS: gdb.opt/inline-cmds.exp: backtrace at inlined_fn from noinline +PASS: gdb.opt/inline-cmds.exp: inlined_fn from noinline inlined +PASS: gdb.opt/inline-cmds.exp: up to noinline +PASS: gdb.opt/inline-cmds.exp: noinline from outer_inline1 not inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline1 +PASS: gdb.opt/inline-cmds.exp: outer_inline1 inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline2 +PASS: gdb.opt/inline-cmds.exp: outer_inline2 inlined +PASS: gdb.opt/inline-cmds.exp: up from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: main not inlined +Running ./gdb.opt/inline-locals.exp ... +PASS: gdb.opt/inline-locals.exp: continue to bar (1) +PASS: gdb.opt/inline-locals.exp: continue to bar (2) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (2) +PASS: gdb.opt/inline-locals.exp: up from bar (2) +PASS: gdb.opt/inline-locals.exp: func1 inlined (2) +PASS: gdb.opt/inline-locals.exp: info locals above bar (2) +PASS: gdb.opt/inline-locals.exp: info args above bar (2) +PASS: gdb.opt/inline-locals.exp: print local (2) +PASS: gdb.opt/inline-locals.exp: print out of scope local +PASS: gdb.opt/inline-locals.exp: continue to bar (3) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (3) +PASS: gdb.opt/inline-locals.exp: up from bar (3) +PASS: gdb.opt/inline-locals.exp: func1 inlined (3) +PASS: gdb.opt/inline-locals.exp: info locals above bar (3) +PASS: gdb.opt/inline-locals.exp: info args above bar (3) +PASS: gdb.opt/inline-locals.exp: print local (3) +Running ./gdb.pascal/floats.exp ... +UNSUPPORTED: gdb.pascal/floats.exp: No pascal compiler found +UNTESTED: gdb.pascal/floats.exp: floats.exp +Running ./gdb.pascal/gdb11492.exp ... +UNSUPPORTED: gdb.pascal/gdb11492.exp: No pascal compiler found +UNTESTED: gdb.pascal/gdb11492.exp: gdb11492.exp +Running ./gdb.pascal/hello.exp ... +UNSUPPORTED: gdb.pascal/hello.exp: No pascal compiler found +Running ./gdb.pascal/integers.exp ... +UNSUPPORTED: gdb.pascal/integers.exp: No pascal compiler found +Running ./gdb.pascal/print.exp ... +PASS: gdb.pascal/print.exp: set language pascal +PASS: gdb.pascal/print.exp: set language to "pascal" +PASS: gdb.pascal/print.exp: check fp + text +PASS: gdb.pascal/print.exp: p 1. +PASS: gdb.pascal/print.exp: p 1.5 +PASS: gdb.pascal/print.exp: p 1.f +PASS: gdb.pascal/print.exp: p 1.5f +PASS: gdb.pascal/print.exp: p 1.l +PASS: gdb.pascal/print.exp: p 1.5l +PASS: gdb.pascal/print.exp: p 0x1.1 +PASS: gdb.pascal/print.exp: reject p 1.1x +PASS: gdb.pascal/print.exp: reject p 1.1ff +PASS: gdb.pascal/print.exp: reject p 1.1ll +Running ./gdb.pascal/types.exp ... +PASS: gdb.pascal/types.exp: set language pascal +PASS: gdb.pascal/types.exp: set language to "pascal" +PASS: gdb.pascal/types.exp: pt 123 +PASS: gdb.pascal/types.exp: pt TRUE +PASS: gdb.pascal/types.exp: pt FALSE +PASS: gdb.pascal/types.exp: pt 'a' +KFAIL: gdb.pascal/types.exp: pt 'a simple string' (PRMS: gdb/2326) +PASS: gdb.pascal/types.exp: pt .44 +PASS: gdb.pascal/types.exp: pt 44.0 +PASS: gdb.pascal/types.exp: pt 10e20 +PASS: gdb.pascal/types.exp: pt 10E20 +Running ./gdb.python/lib-types.exp ... +PASS: gdb.python/lib-types.exp: python import gdb.types +PASS: gdb.python/lib-types.exp: python const_class1_obj = gdb.parse_and_eval ('const_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_class1_obj = gdb.types.get_basic_type (const_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_class1_obj.type)) +PASS: gdb.python/lib-types.exp: const stripping +PASS: gdb.python/lib-types.exp: python volatile_class1_obj = gdb.parse_and_eval ('volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_volatile_class1_obj = gdb.types.get_basic_type (volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile stripping +PASS: gdb.python/lib-types.exp: python const_volatile_class1_obj = gdb.parse_and_eval ('const_volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_volatile_class1_obj = gdb.types.get_basic_type (const_volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile+const stripping +PASS: gdb.python/lib-types.exp: python typedef_class1_obj = gdb.parse_and_eval ('typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_class1_obj = gdb.types.get_basic_type (typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: typedef stripping +PASS: gdb.python/lib-types.exp: python class1_ref_obj = gdb.parse_and_eval ('class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_class1_ref_obj = gdb.types.get_basic_type (class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: reference stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_ref_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_ref_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_const_typedef_class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef/ref stripping +PASS: gdb.python/lib-types.exp: python class1_obj = gdb.parse_and_eval ('class1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'nope')) +PASS: gdb.python/lib-types.exp: python subclass1_obj = gdb.parse_and_eval ('subclass1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (subclass1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python enum1_obj = gdb.parse_and_eval ('enum1_obj') +PASS: gdb.python/lib-types.exp: python enum1_dict = gdb.types.make_enum_dict (enum1_obj.type) +PASS: gdb.python/lib-types.exp: python enum1_list = sorted (enum1_dict.items ()) +PASS: gdb.python/lib-types.exp: python print (enum1_list) +PASS: gdb.python/lib-types.exp: python struct_a = gdb.lookup_type ('struct A') +PASS: gdb.python/lib-types.exp: python print (struct_a.keys ()) +PASS: gdb.python/lib-types.exp: python print ([k for k,v in gdb.types.deep_items(struct_a)]) +Running ./gdb.python/py-arch.exp ... +PASS: gdb.python/py-arch.exp: test number of instructions 1 +PASS: gdb.python/py-arch.exp: test number of instructions 2 +PASS: gdb.python/py-arch.exp: test number of instructions 3 +PASS: gdb.python/py-arch.exp: test number of instructions 4 +PASS: gdb.python/py-arch.exp: test key addr +PASS: gdb.python/py-arch.exp: test key asm +PASS: gdb.python/py-arch.exp: test key length +PASS: gdb.python/py-arch.exp: test exception +Running ./gdb.python/py-block.exp ... +PASS: gdb.python/py-block.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-block.exp: Check block not None +PASS: gdb.python/py-block.exp: First anonymous block +PASS: gdb.python/py-block.exp: Check start not None +PASS: gdb.python/py-block.exp: Check end not None +PASS: gdb.python/py-block.exp: Not a global block +PASS: gdb.python/py-block.exp: Not a static block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Is the global block +PASS: gdb.python/py-block.exp: Is the static block +PASS: gdb.python/py-block.exp: Get superblock +PASS: gdb.python/py-block.exp: Second anonymous block +PASS: gdb.python/py-block.exp: Get superblock 2 +PASS: gdb.python/py-block.exp: Print superblock 2 function +PASS: gdb.python/py-block.exp: up +PASS: gdb.python/py-block.exp: Check Frame 2's block not None +PASS: gdb.python/py-block.exp: main block +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +Running ./gdb.python/py-breakpoint.exp ... +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check for two breakpoints +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: Check expected variable result after 6 iterations +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint enabled. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint thread +PASS: gdb.python/py-breakpoint.exp: Check breakpoint type +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints before delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint invalidated +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints after delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional has been set +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional breakpoint stopped after five iterations +PASS: gdb.python/py-breakpoint.exp: Test conditional read +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test breakpoint stopped after six iterations +PASS: gdb.python/py-breakpoint.exp: commands $bpnum +PASS: gdb.python/py-breakpoint.exp: print "Command for breakpoint has been executed." +PASS: gdb.python/py-breakpoint.exp: print result +PASS: gdb.python/py-breakpoint.exp: end +PASS: gdb.python/py-breakpoint.exp: python print (blist[len(blist)-1].commands) +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints shows visible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - class bp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - inf_i = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.inf_i = gdb.parse_and_eval("i") +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - if self.inf_i == 3: +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - class bp_also_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - if self.count == 9: +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - class basic (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - end +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check inferior value matches python accounting +PASS: gdb.python/py-breakpoint.exp: Check python accounting matches inferior +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check you cannot add a CLI condition to a Python breakpoint that +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - python +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - def stop_func (): +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - return True +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - end +PASS: gdb.python/py-breakpoint.exp: Assign stop function to a breakpoint that has a condition +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function has not been yet executed (ie count = 0) +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function is run when location also has normal bp +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - class wp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - self.result = gdb.parse_and_eval("result") +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - if self.result == 788: +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - end +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check that this unrelated breakpoints eval function was never called. +Running ./gdb.python/py-cmd.exp ... +PASS: gdb.python/py-cmd.exp: input simple command - python +PASS: gdb.python/py-cmd.exp: input simple command - class test_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple command - super (test_cmd, self).__init__ ("test_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input simple command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple command - test_cmd () +PASS: gdb.python/py-cmd.exp: input simple command - end +PASS: gdb.python/py-cmd.exp: call simple command +PASS: gdb.python/py-cmd.exp: input prefix command - python +PASS: gdb.python/py-cmd.exp: input prefix command - class prefix_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command - super (prefix_cmd, self).__init__ ("prefix_cmd", gdb.COMMAND_OBSCURE, gdb.COMPLETE_NONE, True) +PASS: gdb.python/py-cmd.exp: input prefix command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command - print ("prefix_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command - prefix_cmd () +PASS: gdb.python/py-cmd.exp: input prefix command - end +PASS: gdb.python/py-cmd.exp: call prefix command +PASS: gdb.python/py-cmd.exp: input subcommand - python +PASS: gdb.python/py-cmd.exp: input subcommand - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand - super (subcmd, self).__init__ ("prefix_cmd subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand - end +PASS: gdb.python/py-cmd.exp: call subcmd +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - python +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - class prefix_cmd2 (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - super (prefix_cmd2, self).__init__ ("prefix_cmd2", gdb.COMMAND_OBSCURE, prefix = True, completer_class = gdb.COMPLETE_FILENAME) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - print ("prefix_cmd2 output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - prefix_cmd2 () +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - end +PASS: gdb.python/py-cmd.exp: call prefix command, keyword arguments +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - python +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - super (subcmd, self).__init__ ("prefix_cmd2 subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - end +PASS: gdb.python/py-cmd.exp: call subcmd under prefix_cmd2 +PASS: gdb.python/py-cmd.exp: input new subcommand - python +PASS: gdb.python/py-cmd.exp: input new subcommand - class newsubcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input new subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input new subcommand - super (newsubcmd, self).__init__ ("info newsubcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input new subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input new subcommand - print ("newsubcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input new subcommand - newsubcmd () +PASS: gdb.python/py-cmd.exp: input new subcommand - end +PASS: gdb.python/py-cmd.exp: call newsubcmd +PASS: gdb.python/py-cmd.exp: input command to throw error - python +PASS: gdb.python/py-cmd.exp: input command to throw error - class test_error_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input command to throw error - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input command to throw error - super (test_error_cmd, self).__init__ ("test_error_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input command to throw error - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input command to throw error - raise gdb.GdbError ('you lose!') +PASS: gdb.python/py-cmd.exp: input command to throw error - test_error_cmd () +PASS: gdb.python/py-cmd.exp: input command to throw error - end +PASS: gdb.python/py-cmd.exp: call error command +PASS: gdb.python/py-cmd.exp: string_to_argv ("1 2 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ("'1 2' 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ('"1 2" 3') +PASS: gdb.python/py-cmd.exp: string_to_argv ('1\ 2 3') +PASS: gdb.python/py-cmd.exp: input simple user-defined command - python +PASS: gdb.python/py-cmd.exp: input simple user-defined command - class test_help (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - """Docstring""" +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - super (test_help, self).__init__ ("test_help", gdb.COMMAND_USER) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - test_help () +PASS: gdb.python/py-cmd.exp: input simple user-defined command - end +PASS: gdb.python/py-cmd.exp: call simple user-defined command +PASS: gdb.python/py-cmd.exp: see user-defined command in `help user-defined` +Running ./gdb.python/py-error.exp ... +PASS: gdb.python/py-error.exp: set host-charset IBM1047 +PASS: gdb.python/py-error.exp: main reached +PASS: gdb.python/py-error.exp: no delayed error +Running ./gdb.python/py-events.exp ... +Running ./gdb.python/py-evsignal.exp ... +KFAIL: gdb.python/py-evsignal.exp: Signal Thread 3 (PRMS: python/12966) +Running ./gdb.python/py-evthreads.exp ... +KFAIL: gdb.python/py-evthreads.exp: Run to breakpoint 1 (PRMS: python/12966) +Running ./gdb.python/py-explore-cc.exp ... +PASS: gdb.python/py-explore-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore-cc.exp: explore A +PASS: gdb.python/py-explore-cc.exp: explore a +PASS: gdb.python/py-explore-cc.exp: explore int_ref +PASS: gdb.python/py-explore-cc.exp: explore int_ptr_ref +PASS: gdb.python/py-explore-cc.exp: explore_int_ptr_ref_as_single_value_pointer +PASS: gdb.python/py-explore-cc.exp: explore b +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_A +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_b +PASS: gdb.python/py-explore-cc.exp: explore B +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_B +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_c +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_B +Running ./gdb.python/py-explore.exp ... +PASS: gdb.python/py-explore.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore.exp: explore i +PASS: gdb.python/py-explore.exp: explore ss +PASS: gdb.python/py-explore.exp: explore *ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_t +PASS: gdb.python/py-explore.exp: explore ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_ptr as single value pointer +PASS: gdb.python/py-explore.exp: explore darray_ref +PASS: gdb.python/py-explore.exp: no_to_explore_as_pointer +PASS: gdb.python/py-explore.exp: explore_as_array +PASS: gdb.python/py-explore.exp: explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array +PASS: gdb.python/py-explore.exp: explore su +PASS: gdb.python/py-explore.exp: explore su.d +PASS: gdb.python/py-explore.exp: end su.d exploration +PASS: gdb.python/py-explore.exp: end su exploration +PASS: gdb.python/py-explore.exp: explore cs +PASS: gdb.python/py-explore.exp: explore cs.s +PASS: gdb.python/py-explore.exp: end cs.s exploration +PASS: gdb.python/py-explore.exp: explore cs.u +PASS: gdb.python/py-explore.exp: end cs.u exploration +PASS: gdb.python/py-explore.exp: end cs exploration +PASS: gdb.python/py-explore.exp: explore cu +PASS: gdb.python/py-explore.exp: explore cu.sa +PASS: gdb.python/py-explore.exp: explore cu.sa[0] +PASS: gdb.python/py-explore.exp: end cu.sa[0] exploration +PASS: gdb.python/py-explore.exp: end cu.sa exploration +PASS: gdb.python/py-explore.exp: end cu exploration +PASS: gdb.python/py-explore.exp: explore int +PASS: gdb.python/py-explore.exp: explore struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 0 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 1 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore union SimpleUnion +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 0 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 1 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 1 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 2 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 2 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 3 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 3 +PASS: gdb.python/py-explore.exp: return to GDB prompt from union SimpleUnion +PASS: gdb.python/py-explore.exp: explore SS +PASS: gdb.python/py-explore.exp: explore type SS feild 0 +PASS: gdb.python/py-explore.exp: return to SS from field 0 +PASS: gdb.python/py-explore.exp: explore type SS feild 1 +PASS: gdb.python/py-explore.exp: return to SS field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from SS +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 0 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 1 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 1 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 2 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 2 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexStruct type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +Running ./gdb.python/py-finish-breakpoint2.exp ... +PASS: gdb.python/py-finish-breakpoint2.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint2.exp: run to exception 1 +PASS: gdb.python/py-finish-breakpoint2.exp: check BP count +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: check FinishBreakpoint in catch() +PASS: gdb.python/py-finish-breakpoint2.exp: check finish BP removal +PASS: gdb.python/py-finish-breakpoint2.exp: continue to second exception +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: FinishBreakpoint with exception thrown not caught +Running ./gdb.python/py-finish-breakpoint.exp ... +PASS: gdb.python/py-finish-breakpoint.exp: disable confirmation +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: continue to the function to finish +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint with default frame value +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check return_value at init +PASS: gdb.python/py-finish-breakpoint.exp: check MyFinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return_value +PASS: gdb.python/py-finish-breakpoint.exp: check finishBP on default frame has been hit +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer normal hit +PASS: gdb.python/py-finish-breakpoint.exp: return to main() +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP not allowed in main +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: ensure that shared lib has no debug info +PASS: gdb.python/py-finish-breakpoint.exp: continue to do_nothing +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return value without debug symbol +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: set BP after the jump +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set a conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP in a breakpoint condition +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set BP in condition +PASS: gdb.python/py-finish-breakpoint.exp: stop in condition function +PASS: gdb.python/py-finish-breakpoint.exp: finish condition evaluation +PASS: gdb.python/py-finish-breakpoint.exp: stop at conditional breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: FinishBP stop at during explicit function call +PASS: gdb.python/py-finish-breakpoint.exp: switch to exit() test +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exit() +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exit +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exec +PASS: gdb.python/py-finish-breakpoint.exp: catch exec +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exec +Running ./gdb.python/py-frame.exp ... +PASS: gdb.python/py-frame.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame.exp: test Frame.architecture() +PASS: gdb.python/py-frame.exp: test i +PASS: gdb.python/py-frame.exp: test f +PASS: gdb.python/py-frame.exp: test b +PASS: gdb.python/py-frame.exp: test i = 1.1 +PASS: gdb.python/py-frame.exp: test double i +PASS: gdb.python/py-frame.exp: test f = 2.2 +PASS: gdb.python/py-frame.exp: test double f +PASS: gdb.python/py-frame.exp: test i = 99 +PASS: gdb.python/py-frame.exp: test int i +PASS: gdb.python/py-frame.exp: continue to breakpoint: breakpoint at f2 +PASS: gdb.python/py-frame.exp: selected frame -vs- newest frame +PASS: gdb.python/py-frame.exp: newest frame -vs- newest frame +PASS: gdb.python/py-frame.exp: test equality comparison (false) +PASS: gdb.python/py-frame.exp: test equality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (false) +PASS: gdb.python/py-frame.exp: test Frame.is_valid +PASS: gdb.python/py-frame.exp: test Frame.name +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test gdb.frame_stop_reason_string +PASS: gdb.python/py-frame.exp: test Frame.pc +PASS: gdb.python/py-frame.exp: test Frame.older +PASS: gdb.python/py-frame.exp: test Frame.newer +PASS: gdb.python/py-frame.exp: test Frame.read_var - error +PASS: gdb.python/py-frame.exp: test Frame.read_var - success +PASS: gdb.python/py-frame.exp: test gdb.selected_frame +Running ./gdb.python/py-frame-inline.exp ... +PASS: gdb.python/py-frame-inline.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame-inline.exp: info frame +PASS: gdb.python/py-frame-inline.exp: up +PASS: gdb.python/py-frame-inline.exp: python print (gdb.selected_frame().read_var('l')) +Running ./gdb.python/py-function.exp ... +PASS: gdb.python/py-function.exp: input convenience function - python +PASS: gdb.python/py-function.exp: input convenience function - class test_func (gdb.Function): +PASS: gdb.python/py-function.exp: input convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input convenience function - super (test_func, self).__init__ ("test_func") +PASS: gdb.python/py-function.exp: input convenience function - def invoke (self, arg): +PASS: gdb.python/py-function.exp: input convenience function - return "test_func output, arg = %s" % arg.string () +PASS: gdb.python/py-function.exp: input convenience function - test_func () +PASS: gdb.python/py-function.exp: input convenience function - end +PASS: gdb.python/py-function.exp: call function +PASS: gdb.python/py-function.exp: input value-returning convenience function - python +PASS: gdb.python/py-function.exp: input value-returning convenience function - class Double (gdb.Function): +PASS: gdb.python/py-function.exp: input value-returning convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input value-returning convenience function - super (Double, self).__init__ ("double") +PASS: gdb.python/py-function.exp: input value-returning convenience function - def invoke (self, n): +PASS: gdb.python/py-function.exp: input value-returning convenience function - return n*2 +PASS: gdb.python/py-function.exp: input value-returning convenience function - Double () +PASS: gdb.python/py-function.exp: input value-returning convenience function - end +PASS: gdb.python/py-function.exp: call value-returning function +PASS: gdb.python/py-function.exp: input int-returning function - python +PASS: gdb.python/py-function.exp: input int-returning function - class Yes(gdb.Function): +PASS: gdb.python/py-function.exp: input int-returning function - def __init__(self): +PASS: gdb.python/py-function.exp: input int-returning function - gdb.Function.__init__(self, 'yes') +PASS: gdb.python/py-function.exp: input int-returning function - def invoke(self): +PASS: gdb.python/py-function.exp: input int-returning function - return 1 +PASS: gdb.python/py-function.exp: input int-returning function - Yes () +PASS: gdb.python/py-function.exp: input int-returning function - end +PASS: gdb.python/py-function.exp: call yes with && +PASS: gdb.python/py-function.exp: call yes with || +PASS: gdb.python/py-function.exp: Test GDBError - python +PASS: gdb.python/py-function.exp: Test GDBError - class GDBError(gdb.Function): +PASS: gdb.python/py-function.exp: Test GDBError - def __init__(self): +PASS: gdb.python/py-function.exp: Test GDBError - gdb.Function.__init__(self, 'gdberror') +PASS: gdb.python/py-function.exp: Test GDBError - def invoke(self): +PASS: gdb.python/py-function.exp: Test GDBError - raise gdb.GdbError("This is a GdbError") +PASS: gdb.python/py-function.exp: Test GDBError - GDBError () +PASS: gdb.python/py-function.exp: Test GDBError - end +PASS: gdb.python/py-function.exp: Test GdbError. There should not be a stack trace +PASS: gdb.python/py-function.exp: Test Normal Error - python +PASS: gdb.python/py-function.exp: Test Normal Error - class NormalError(gdb.Function): +PASS: gdb.python/py-function.exp: Test Normal Error - def __init__(self): +PASS: gdb.python/py-function.exp: Test Normal Error - gdb.Function.__init__(self, 'normalerror') +PASS: gdb.python/py-function.exp: Test Normal Error - def invoke(self): +PASS: gdb.python/py-function.exp: Test Normal Error - raise RuntimeError("This is a Normal Error") +PASS: gdb.python/py-function.exp: Test Normal Error - NormalError () +PASS: gdb.python/py-function.exp: Test Normal Error - end +PASS: gdb.python/py-function.exp: set python print-stack full +PASS: gdb.python/py-function.exp: Test a Runtime error. There should be a stack trace. +PASS: gdb.python/py-function.exp: input command-calling function - python +PASS: gdb.python/py-function.exp: input command-calling function - class CallCommand(gdb.Function): +PASS: gdb.python/py-function.exp: input command-calling function - def __init__(self): +PASS: gdb.python/py-function.exp: input command-calling function - gdb.Function.__init__(self, 'call_command') +PASS: gdb.python/py-function.exp: input command-calling function - def invoke(self): +PASS: gdb.python/py-function.exp: input command-calling function - return gdb.execute('print 1', to_string=True) +PASS: gdb.python/py-function.exp: input command-calling function - CallCommand () +PASS: gdb.python/py-function.exp: input command-calling function - end +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command. +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command, again. +Running ./gdb.python/py-inferior.exp ... +PASS: gdb.python/py-inferior.exp: successfully compiled posix threads test case +PASS: gdb.python/py-inferior.exp: get inferiors list +PASS: gdb.python/py-inferior.exp: verify inferiors list +PASS: gdb.python/py-inferior.exp: test equality comparison (true) +PASS: gdb.python/py-inferior.exp: test Inferior.num +PASS: gdb.python/py-inferior.exp: test Inferior.pid +PASS: gdb.python/py-inferior.exp: test Inferior.was_attached +PASS: gdb.python/py-inferior.exp: test Inferior.threads +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to check_threads +PASS: gdb.python/py-inferior.exp: test Inferior.threads 2 +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to Break here. +PASS: gdb.python/py-inferior.exp: read str contents +PASS: gdb.python/py-inferior.exp: write str +PASS: gdb.python/py-inferior.exp: ensure str was changed in the inferior +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: find string pattern +PASS: gdb.python/py-inferior.exp: pattern not found at end of range +PASS: gdb.python/py-inferior.exp: pattern found at end of range +PASS: gdb.python/py-inferior.exp: py from struct import * +PASS: gdb.python/py-inferior.exp: set int16_search_buf[10] = 0x1234 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int16_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<H',0x1234) +PASS: gdb.python/py-inferior.exp: find 16-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set int32_search_buf[10] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int32_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I',0x12345678) +PASS: gdb.python/py-inferior.exp: find 32-bit pattern, with python pattern +PASS: gdb.python/py-inferior.exp: set int64_search_buf[10] = 0xfedcba9876543210LL +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int64_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<Q', 0xfedcba9876543210) +PASS: gdb.python/py-inferior.exp: find 64-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set *(int8_t*) &search_buf[10] = 0x62 +PASS: gdb.python/py-inferior.exp: set *(int16_t*) &search_buf[11] = 0x6363 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[13] = 0x64646464 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf[0].address +PASS: gdb.python/py-inferior.exp: py pattern1 = pack('B', 0x62) +PASS: gdb.python/py-inferior.exp: py pattern2 = pack('<H', 0x6363) +PASS: gdb.python/py-inferior.exp: py pattern3 = pack('<I', 0x64646464) +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[0*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[1*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py start_addr = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py end_addr = start_addr + gdb.selected_frame ().read_var ('search_buf_size') +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I', 0x12345678) +PASS: gdb.python/py-inferior.exp: py first = gdb.inferiors()[0].search_memory (start_addr,end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 1st result +PASS: gdb.python/py-inferior.exp: py start_addr = first + 1 +PASS: gdb.python/py-inferior.exp: py second = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 2nd result +PASS: gdb.python/py-inferior.exp: py start_addr = second + 1 +PASS: gdb.python/py-inferior.exp: py third = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 3rd result +PASS: gdb.python/py-inferior.exp: get initial list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: add empty inferior 2 +PASS: gdb.python/py-inferior.exp: get new list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: remove-inferiors 3 +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: First inferior selected +PASS: gdb.python/py-inferior.exp: Create new inferior +PASS: gdb.python/py-inferior.exp: Switch to third inferior +PASS: gdb.python/py-inferior.exp: Third inferior selected +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: Remove second inferior +Running ./gdb.python/py-infthread.exp ... +PASS: gdb.python/py-infthread.exp: test gdb.selected_thread +PASS: gdb.python/py-infthread.exp: verify InferiorThread object +PASS: gdb.python/py-infthread.exp: test Inferior.num +PASS: gdb.python/py-infthread.exp: test InferiorThread.ptid +PASS: gdb.python/py-infthread.exp: get supplied name of current thread +PASS: gdb.python/py-infthread.exp: set name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread +PASS: gdb.python/py-infthread.exp: reset name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread again +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_stopped +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_running +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_exited +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +PASS: gdb.python/py-infthread.exp: kill inferior 1 +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +Running ./gdb.python/py-mi.exp ... +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 328 (set breakpoint) +PASS: gdb.python/py-mi.exp: create container varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine container children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create nscont varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine nscont children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create string_1 varobj +PASS: gdb.python/py-mi.exp: create estring varobj +PASS: gdb.python/py-mi.exp: assign string_1 from string_2 +PASS: gdb.python/py-mi.exp: update string varobj after assignment +PASS: gdb.python/py-mi.exp: create container varobj +PASS: gdb.python/py-mi.exp: examine container children=0 +PASS: gdb.python/py-mi.exp: next over update 1 +PASS: gdb.python/py-mi.exp: varobj update 1 +PASS: gdb.python/py-mi.exp: next over update 2 +PASS: gdb.python/py-mi.exp: varobj update 2 +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: varobj update after choosing default +PASS: gdb.python/py-mi.exp: choose visualizer using expression +PASS: gdb.python/py-mi.exp: varobj update after choosing via expression +PASS: gdb.python/py-mi.exp: list varobj children after selecting child range +PASS: gdb.python/py-mi.exp: list varobj children after resetting child range +PASS: gdb.python/py-mi.exp: next over update 3 +PASS: gdb.python/py-mi.exp: set update range +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: list selected children after setting range +PASS: gdb.python/py-mi.exp: list children after listing selected range +PASS: gdb.python/py-mi.exp: next over update 4 +PASS: gdb.python/py-mi.exp: update after next with restricted range +PASS: gdb.python/py-mi.exp: set update range with non-zero start +PASS: gdb.python/py-mi.exp: update varobj with change outside selected range +PASS: gdb.python/py-mi.exp: next over update 5 +PASS: gdb.python/py-mi.exp: create second container varobj +PASS: gdb.python/py-mi.exp: update varobj, no children requested +PASS: gdb.python/py-mi.exp: next over update 6 +PASS: gdb.python/py-mi.exp: update varobj 2, no children requested +PASS: gdb.python/py-mi.exp: run to 131 (set breakpoint) +PASS: gdb.python/py-mi.exp: create outer varobj +PASS: gdb.python/py-mi.exp: list children of outer +PASS: gdb.python/py-mi.exp: list children of outer.s +PASS: gdb.python/py-mi.exp: next over outer update +PASS: gdb.python/py-mi.exp: update after updating element of outer +PASS: gdb.python/py-mi.exp: run to 222 (set breakpoint) +PASS: gdb.python/py-mi.exp: update after type change +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create nstype varobj +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: create nstype2 varobj +PASS: gdb.python/py-mi.exp: list children after setting exception flag +PASS: gdb.python/py-mi.exp: create me varobj +PASS: gdb.python/py-mi.exp: evaluate me varobj +PASS: gdb.python/py-mi.exp: printer whose children are returned as a list +PASS: gdb.python/py-mi.exp: run to 254 (set breakpoint) +PASS: gdb.python/py-mi.exp: create varobj for c +PASS: gdb.python/py-mi.exp: choose array visualizer for c +PASS: gdb.python/py-mi.exp: list children of c +PASS: gdb.python/py-mi.exp: next over change of array element +PASS: gdb.python/py-mi.exp: update varobj after element change +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create fake varobj +PASS: gdb.python/py-mi.exp: list children of fake +PASS: gdb.python/py-mi.exp: list children fake.private +PASS: gdb.python/py-mi.exp: Install visualizer on a cplus_fake_child +Running ./gdb.python/py-objfile.exp ... +PASS: gdb.python/py-objfile.exp: Find a symbol in objfile +PASS: gdb.python/py-objfile.exp: Get backing object file +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity after unload +Running ./gdb.python/py-objfile-script.exp ... +PASS: gdb.python/py-objfile-script.exp: set auto-load safe-path +PASS: gdb.python/py-objfile-script.exp: info auto-load python-scripts +PASS: gdb.python/py-objfile-script.exp: b 38 +PASS: gdb.python/py-objfile-script.exp: continue +PASS: gdb.python/py-objfile-script.exp: print ss +Running ./gdb.python/py-parameter.exp ... +PASS: gdb.python/py-parameter.exp: python print (gdb.parameter ('directories')) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "Show the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: enum gdb parameter - python +PASS: gdb.python/py-parameter.exp: enum gdb parameter - class TestEnumParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - show_doc = "Show the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - set_doc = "Set the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum is " + pvalue +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum has been set to " + self.value +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - super (TestEnumParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_ENUM, ["one", "two"]) +PASS: gdb.python/py-parameter.exp: enum gdb parameter - self.value = "one" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - test_enum_param = TestEnumParam ('print test-enum-param') +PASS: gdb.python/py-parameter.exp: enum gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Show parameter is initial value +PASS: gdb.python/py-parameter.exp: Set enum to two +PASS: gdb.python/py-parameter.exp: Show parameter is new value +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Set invalid enum parameter +PASS: gdb.python/py-parameter.exp: file gdb parameter - python +PASS: gdb.python/py-parameter.exp: file gdb parameter - class TestFileParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: file gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: file gdb parameter - show_doc = "Show the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - set_doc = "Set the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file is " + pvalue +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file has been changed to " + self.value +PASS: gdb.python/py-parameter.exp: file gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: file gdb parameter - super (TestFileParam, self).__init__ (name, gdb.COMMAND_FILES, gdb.PARAM_FILENAME) +PASS: gdb.python/py-parameter.exp: file gdb parameter - self.value = "foo.txt" +PASS: gdb.python/py-parameter.exp: file gdb parameter - test_file_param = TestFileParam ('test-file-param') +PASS: gdb.python/py-parameter.exp: file gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test file parameter value +PASS: gdb.python/py-parameter.exp: Show initial file value +PASS: gdb.python/py-parameter.exp: Set new file parameter +PASS: gdb.python/py-parameter.exp: Show new file value +PASS: gdb.python/py-parameter.exp: Test new file parameter value +PASS: gdb.python/py-parameter.exp: set test-file-param +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestUndocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestUndocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_undoc_param = TestUndocParam ('print test-undoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestNodocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestNodocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_nodoc_param = TestNodocParam ('print test-nodoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "State of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +Running ./gdb.python/py-pp-maint.exp ... +PASS: gdb.python/py-pp-maint.exp: b 77 +PASS: gdb.python/py-pp-maint.exp: continue +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt enabled #1 +PASS: gdb.python/py-pp-maint.exp: print ss enabled #1 +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt disabled +PASS: gdb.python/py-pp-maint.exp: print ss disabled +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*ss.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*s.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: print flt re-enabled +PASS: gdb.python/py-pp-maint.exp: print ss re-enabled +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | FLAG_3 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | 8 +Running ./gdb.python/py-prettyprint.exp ... +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +PASS: gdb.python/py-prettyprint.exp: continue until exit +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print cps +PASS: gdb.python/py-prettyprint.exp: print cpss +PASS: gdb.python/py-prettyprint.exp: print cpssa[0] +PASS: gdb.python/py-prettyprint.exp: print cpssa[1] +PASS: gdb.python/py-prettyprint.exp: print cpssa +PASS: gdb.python/py-prettyprint.exp: print sss +PASS: gdb.python/py-prettyprint.exp: print ref +PASS: gdb.python/py-prettyprint.exp: print derived +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +PASS: gdb.python/py-prettyprint.exp: continue until exit +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: continue to breakpoint: eval-break +PASS: gdb.python/py-prettyprint.exp: info locals +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: print ss enabled #1 +PASS: gdb.python/py-prettyprint.exp: python disable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss disabled +PASS: gdb.python/py-prettyprint.exp: python enable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss enabled #2 +Running ./gdb.python/py-progspace.exp ... +PASS: gdb.python/py-progspace.exp: current progspace filename (None) +PASS: gdb.python/py-progspace.exp: python print (gdb.progspaces()) +PASS: gdb.python/py-progspace.exp: current progspace filename (py-progspace) +Running ./gdb.python/py-prompt.exp ... +Running ./gdb.python/py-section-script.exp ... +PASS: gdb.python/py-section-script.exp: set auto-load safe-path +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts py-section-script +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts no-script-matches-this +PASS: gdb.python/py-section-script.exp: b 51 +PASS: gdb.python/py-section-script.exp: continue +PASS: gdb.python/py-section-script.exp: print ss +Running ./gdb.python/py-shared.exp ... +PASS: gdb.python/py-shared.exp: func1 address +PASS: gdb.python/py-shared.exp: Aquire func1 address +PASS: gdb.python/py-shared.exp: test func1 solib location +PASS: gdb.python/py-shared.exp: main address +PASS: gdb.python/py-shared.exp: Aquire main address +PASS: gdb.python/py-shared.exp: test main solib location +Running ./gdb.python/py-strfns.exp ... +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str2) +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str3) +PASS: gdb.python/py-strfns.exp: p $_strlen (str1) +PASS: gdb.python/py-strfns.exp: p $_strlen (buf1) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf2, 4) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf3, 4) +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Help") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello.$") +PASS: gdb.python/py-strfns.exp: condition $bpnum $_streq (arg, "Goodbye.") +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break func here. +PASS: gdb.python/py-strfns.exp: p arg +PASS: gdb.python/py-strfns.exp: condition $bpnum $_memeq (arg, buf3, 4) +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break bfunc here. +PASS: gdb.python/py-strfns.exp: p /d {char[4]} arg +PASS: gdb.python/py-strfns.exp: save a corefile +FAIL: gdb.python/py-strfns.exp: re-load generated corefile +Running ./gdb.python/py-symbol.exp ... +PASS: gdb.python/py-symbol.exp: Lookup main +PASS: gdb.python/py-symbol.exp: Test main_func.is_function +PASS: gdb.python/py-symbol.exp: Test lookup_global_symbol("junk") +PASS: gdb.python/py-symbol.exp: print value of main +PASS: gdb.python/py-symbol.exp: print line number of qq +PASS: gdb.python/py-symbol.exp: print value of qq +PASS: gdb.python/py-symbol.exp: print whether qq needs a frame +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symbol.exp: Test arg.is_variable +PASS: gdb.python/py-symbol.exp: Test arg.is_constant +PASS: gdb.python/py-symbol.exp: Test arg.is_argument +PASS: gdb.python/py-symbol.exp: Test arg.is_function +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test a.is_variable +PASS: gdb.python/py-symbol.exp: Test a.is_constant +PASS: gdb.python/py-symbol.exp: Test a.is_argument +PASS: gdb.python/py-symbol.exp: Test a.is_function +PASS: gdb.python/py-symbol.exp: Test a.addr_class +PASS: gdb.python/py-symbol.exp: try to print value of a without a frame +PASS: gdb.python/py-symbol.exp: print value of a +PASS: gdb.python/py-symbol.exp: print whether a needs a frame +PASS: gdb.python/py-symbol.exp: Test t.is_variable +PASS: gdb.python/py-symbol.exp: Test t.is_constant +PASS: gdb.python/py-symbol.exp: Test t.is_argument +PASS: gdb.python/py-symbol.exp: Test t.is_function +PASS: gdb.python/py-symbol.exp: Test t.addr_class +PASS: gdb.python/py-symbol.exp: Get type +PASS: gdb.python/py-symbol.exp: Get symtab +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break in class. +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol destructor +Running ./gdb.python/py-symtab.exp ... +PASS: gdb.python/py-symtab.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symtab.exp: Test symtab +PASS: gdb.python/py-symtab.exp: Test sal.pc +PASS: gdb.python/py-symtab.exp: Test sal.last +PASS: gdb.python/py-symtab.exp: Test sal.line +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.filename +PASS: gdb.python/py-symtab.exp: Test symtab.objfile +PASS: gdb.python/py-symtab.exp: Test symtab.fullname +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test qq in global symbols +PASS: gdb.python/py-symtab.exp: Test func in global symbols +PASS: gdb.python/py-symtab.exp: Test main in global symbols +PASS: gdb.python/py-symtab.exp: Test int in static symbols +PASS: gdb.python/py-symtab.exp: Test char in static symbols +PASS: gdb.python/py-symtab.exp: Test simple_struct in static symbols +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test sal destructor +PASS: gdb.python/py-symtab.exp: Test symtab destructor +Running ./gdb.python/py-template.exp ... +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const * +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile * const * volatile * +Running ./gdb.python/python.exp ... +PASS: gdb.python/python.exp: multi-line python command - python +PASS: gdb.python/python.exp: multi-line python command - print (23) +PASS: gdb.python/python.exp: multi-line python command - end +PASS: gdb.python/python.exp: show python command - define zzq +PASS: gdb.python/python.exp: show python command - python +PASS: gdb.python/python.exp: show python command - print (23) +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - show user zzq +PASS: gdb.python/python.exp: indented multi-line python command - python +PASS: gdb.python/python.exp: indented multi-line python command - def foo (): +PASS: gdb.python/python.exp: indented multi-line python command - print ('hello, world!') +PASS: gdb.python/python.exp: indented multi-line python command - foo () +PASS: gdb.python/python.exp: indented multi-line python command - end +PASS: gdb.python/python.exp: source source2.py +PASS: gdb.python/python.exp: source -s source2.py +PASS: gdb.python/python.exp: python print (gdb.current_objfile()) +PASS: gdb.python/python.exp: python print (gdb.objfiles()) +PASS: gdb.python/python.exp: pythonX.Y/lib-dynload/*.so +PASS: gdb.python/python.exp: python x = gdb.execute('printf "%d", 23', to_string = True) +PASS: gdb.python/python.exp: python print (x) +PASS: gdb.python/python.exp: post event insertion - python +PASS: gdb.python/python.exp: post event insertion - someVal = 0 +PASS: gdb.python/python.exp: post event insertion - class Foo(object): +PASS: gdb.python/python.exp: post event insertion - def __call__(self): +PASS: gdb.python/python.exp: post event insertion - global someVal +PASS: gdb.python/python.exp: post event insertion - someVal += 1 +PASS: gdb.python/python.exp: post event insertion - gdb.post_event(Foo()) +PASS: gdb.python/python.exp: post event insertion - end +PASS: gdb.python/python.exp: test post event execution +PASS: gdb.python/python.exp: Test non callable class +PASS: gdb.python/python.exp: show height +PASS: gdb.python/python.exp: set height 10 +PASS: gdb.python/python.exp: verify pagination beforehand +PASS: gdb.python/python.exp: verify pagination beforehand: q +PASS: gdb.python/python.exp: gdb.execute does not page +PASS: gdb.python/python.exp: verify pagination afterwards +PASS: gdb.python/python.exp: verify pagination afterwards: q +PASS: gdb.python/python.exp: set height 0 +PASS: gdb.python/python.exp: collect help from uiout +PASS: gdb.python/python.exp: verify help to uiout +PASS: gdb.python/python.exp: Attempt to aquire thread with no inferior +PASS: gdb.python/python.exp: Ensure that no threads are returned +PASS: gdb.python/python.exp: register atexit function - python +PASS: gdb.python/python.exp: register atexit function - import atexit +PASS: gdb.python/python.exp: register atexit function - def printit(arg): +PASS: gdb.python/python.exp: register atexit function - print (arg) +PASS: gdb.python/python.exp: register atexit function - atexit.register(printit, 'good bye world') +PASS: gdb.python/python.exp: register atexit function - end +PASS: gdb.python/python.exp: atexit handling +PASS: gdb.python/python.exp: test decode_line no source named main +PASS: gdb.python/python.exp: test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current locationn filename +PASS: gdb.python/python.exp: Test decode_line current location line number +PASS: gdb.python/python.exp: test decode_line python.c:26 +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line python.c:26 filename +PASS: gdb.python/python.exp: Test decode_line python.c:26 line number +PASS: gdb.python/python.exp: test decode_line randomfunc +PASS: gdb.python/python.exp: test decode_line func1() +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 filename +PASS: gdb.python/python.exp: Test decode_line func1 line number +PASS: gdb.python/python.exp: test decode_line func1,func2 +PASS: gdb.python/python.exp: stop at comma in linespec +PASS: gdb.python/python.exp: Test stderr location +PASS: gdb.python/python.exp: Test stdout location +PASS: gdb.python/python.exp: Test default write +PASS: gdb.python/python.exp: Test stderr write +PASS: gdb.python/python.exp: Test stdout write +PASS: gdb.python/python.exp: Test stdlog write +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: prompt substitution - python +PASS: gdb.python/python.exp: prompt substitution - someCounter = 0 +PASS: gdb.python/python.exp: prompt substitution - def prompt(current): +PASS: gdb.python/python.exp: prompt substitution - global someCounter +PASS: gdb.python/python.exp: prompt substitution - if (current == "testfake "): +PASS: gdb.python/python.exp: prompt substitution - return None +PASS: gdb.python/python.exp: prompt substitution - someCounter = someCounter + 1 +PASS: gdb.python/python.exp: prompt substitution - return "py prompt " + str (someCounter) + " " +PASS: gdb.python/python.exp: prompt substitution - end +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def program_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - global pCounter +PASS: gdb.python/python.exp: prompt substitution readline - if (current == ">"): +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = pCounter + 1 +PASS: gdb.python/python.exp: prompt substitution readline - return "python line " + str (pCounter) + ": " +PASS: gdb.python/python.exp: prompt substitution readline - return None +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set prompt testfake +PASS: gdb.python/python.exp: show prompt shows guarded prompt +PASS: gdb.python/python.exp: set prompt blah overriden +PASS: gdb.python/python.exp: Delete old hook +PASS: gdb.python/python.exp: set default prompt +PASS: gdb.python/python.exp: set programming hook +PASS: gdb.python/python.exp: readline secondary are not substituted +PASS: gdb.python/python.exp: end programming +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - import gdb.command.prompt +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set basic extended prompt +PASS: gdb.python/python.exp: set extended prompt working directory +PASS: gdb.python/python.exp: set extended prompt parameter +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to none. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def error_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - raise RuntimeError("Python exception called") +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Get line number of func2 call site +PASS: gdb.python/python.exp: Test find_pc_line at func2 call site +PASS: gdb.python/python.exp: Step into func2 +PASS: gdb.python/python.exp: Step out of func2 +PASS: gdb.python/python.exp: Test find_pc_line with resume address +Running ./gdb.python/py-type.exp ... +PASS: gdb.python/py-type.exp: lang_c: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_c: test_fields: c typedef field list +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_c: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_c: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_c: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum fields items list +PASS: gdb.python/py-type.exp: lang_cpp: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: c++ typedef field list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (c) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from c.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field c name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field d name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type.fields()[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: print value (d) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: get value (d) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: extract type fields from d +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[0]) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[1]) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check correct tuple length +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get fields +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: Check range for non ranged type. +PASS: gdb.python/py-type.exp: lang_cpp: get type of temvar +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(0)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(0), gdb.Type)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(1)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(1), gdb.Value)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(2)) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum fields items list +Running ./gdb.python/py-typeprint.exp ... +PASS: gdb.python/py-typeprint.exp: python exec (open ('py-typeprint.py').read ()) +PASS: gdb.python/py-typeprint.exp: basic test +PASS: gdb.python/py-typeprint.exp: raw test +PASS: gdb.python/py-typeprint.exp: disable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with disabled printer +PASS: gdb.python/py-typeprint.exp: info type-printers +PASS: gdb.python/py-typeprint.exp: enable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with enabled printer +PASS: gdb.python/py-typeprint.exp: whatis s +Running ./gdb.python/py-value-cc.exp ... +PASS: gdb.python/py-value-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").dereference().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().dereference())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().referenced_value())) +Running ./gdb.python/py-value.exp ... +PASS: gdb.python/py-value.exp: create boolean value +PASS: gdb.python/py-value.exp: create integer value +PASS: gdb.python/py-value.exp: create long value +PASS: gdb.python/py-value.exp: create double value +PASS: gdb.python/py-value.exp: create 8-bit string value +PASS: gdb.python/py-value.exp: print 8-bit string +PASS: gdb.python/py-value.exp: verify type of 8-bit string +PASS: gdb.python/py-value.exp: create unicode value +PASS: gdb.python/py-value.exp: print Unicode string +PASS: gdb.python/py-value.exp: verify type of unicode string +PASS: gdb.python/py-value.exp: Test address attribute in non-addressable value +PASS: gdb.python/py-value.exp: add two integer values +PASS: gdb.python/py-value.exp: verify type of integer add result +PASS: gdb.python/py-value.exp: add two double values +PASS: gdb.python/py-value.exp: subtract two integer values +PASS: gdb.python/py-value.exp: subtract two double values +PASS: gdb.python/py-value.exp: multiply two integer values +PASS: gdb.python/py-value.exp: multiply two double values +PASS: gdb.python/py-value.exp: divide two integer values +PASS: gdb.python/py-value.exp: divide two double values +PASS: gdb.python/py-value.exp: take remainder of two integer values +PASS: gdb.python/py-value.exp: integer value raised to the power of another integer value +PASS: gdb.python/py-value.exp: double value raised to the power of integer value +PASS: gdb.python/py-value.exp: negated integer value +PASS: gdb.python/py-value.exp: positive integer value +PASS: gdb.python/py-value.exp: negated double value +PASS: gdb.python/py-value.exp: positive double value +PASS: gdb.python/py-value.exp: absolute of integer value +PASS: gdb.python/py-value.exp: absolute of double value +PASS: gdb.python/py-value.exp: subtract integer value from python integer +PASS: gdb.python/py-value.exp: verify type of mixed integer subtraction result +PASS: gdb.python/py-value.exp: add double value with python float +PASS: gdb.python/py-value.exp: subtract python integer from integer value +PASS: gdb.python/py-value.exp: add python float with double value +PASS: gdb.python/py-value.exp: print evalue +PASS: gdb.python/py-value.exp: python evalue = gdb.history (0) +PASS: gdb.python/py-value.exp: python print (int (evalue)) +PASS: gdb.python/py-value.exp: add pointer value with python integer +PASS: gdb.python/py-value.exp: subtract python integer from pointer value +PASS: gdb.python/py-value.exp: subtract two pointer values +PASS: gdb.python/py-value.exp: catch error in python type conversion +PASS: gdb.python/py-value.exp: catch throw of GDB error +PASS: gdb.python/py-value.exp: define function to test booleans - python +PASS: gdb.python/py-value.exp: define function to test booleans - def test_bool (val): +PASS: gdb.python/py-value.exp: define function to test booleans - if val: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('yay') +PASS: gdb.python/py-value.exp: define function to test booleans - else: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('nay') +PASS: gdb.python/py-value.exp: define function to test booleans - end +PASS: gdb.python/py-value.exp: check evaluation of true boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of false boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: less than, equal +PASS: gdb.python/py-value.exp: less than, less +PASS: gdb.python/py-value.exp: less than, greater +PASS: gdb.python/py-value.exp: less than, None +PASS: gdb.python/py-value.exp: less or equal, equal +PASS: gdb.python/py-value.exp: less or equal, less +PASS: gdb.python/py-value.exp: less or equal, greater +PASS: gdb.python/py-value.exp: less or equal, None +PASS: gdb.python/py-value.exp: equality of gdb.Values +PASS: gdb.python/py-value.exp: inequality of gdb.Values +PASS: gdb.python/py-value.exp: equality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with None +PASS: gdb.python/py-value.exp: inequality, false +PASS: gdb.python/py-value.exp: inequality, true +PASS: gdb.python/py-value.exp: inequality, None +PASS: gdb.python/py-value.exp: greater than, equal +PASS: gdb.python/py-value.exp: greater than, less +PASS: gdb.python/py-value.exp: greater than, greater +PASS: gdb.python/py-value.exp: greater than, None +PASS: gdb.python/py-value.exp: greater or equal, equal +PASS: gdb.python/py-value.exp: greater or equal, less +PASS: gdb.python/py-value.exp: greater or equal, greater +PASS: gdb.python/py-value.exp: greater or equal, None +PASS: gdb.python/py-value.exp: py-value in file.filename +PASS: gdb.python/py-value.exp: python print (gdb.objfiles()[0].pretty_printers) +PASS: gdb.python/py-value.exp: python gdb.objfiles()[0].pretty_printers = 0 +PASS: gdb.python/py-value.exp: parse_and_eval constant test +PASS: gdb.python/py-value.exp: parse_and_eval simple expression test +PASS: gdb.python/py-value.exp: parse_and_eval type test +PASS: gdb.python/py-value.exp: Simple Python value dictionary - python +PASS: gdb.python/py-value.exp: Simple Python value dictionary - one = gdb.Value(1) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - two = gdb.Value(2) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - three = gdb.Value(3) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - vdict = {one:"one str",two:"two str",three:"three str"} +PASS: gdb.python/py-value.exp: Simple Python value dictionary - end +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test inbuilt hash +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: access element inside struct using 8-bit string name +PASS: gdb.python/py-value.exp: access element inside struct using unicode name +PASS: gdb.python/py-value.exp: dereference value +PASS: gdb.python/py-value.exp: Test is_optimized_out attribute +PASS: gdb.python/py-value.exp: Test address attribute +PASS: gdb.python/py-value.exp: parse_and_eval with memory error +PASS: gdb.python/py-value.exp: python inval = gdb.parse_and_eval('*(int*)0') +PASS: gdb.python/py-value.exp: python print (inval.is_lazy) +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: python argc_lazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy.fetch_lazy() +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: python print (argc_notlazy.is_lazy) +PASS: gdb.python/py-value.exp: sanity check argc +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: set argc=2 +PASS: gdb.python/py-value.exp: python print (argc_notlazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: print st +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string with no length +PASS: gdb.python/py-value.exp: Test string (length = -1) is all of the string +PASS: gdb.python/py-value.exp: python print (st.string (length = 6)) +PASS: gdb.python/py-value.exp: Test string (length = 0) is empty +PASS: gdb.python/py-value.exp: Test length is 0 +PASS: gdb.python/py-value.exp: print nullst +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string to first null +PASS: gdb.python/py-value.exp: get string beyond null +PASS: gdb.python/py-value.exp: python print (repr(nullst)) +PASS: gdb.python/py-value.exp: p/x fp1 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp1 = fp1.dereference() +PASS: gdb.python/py-value.exp: python result = fp1() +PASS: gdb.python/py-value.exp: python print (result) +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp2 = fp2.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp2(10,20) +PASS: gdb.python/py-value.exp: python print (result2) +PASS: gdb.python/py-value.exp: p i +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python result3 = i() +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp3 = fp3.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp3(10) +PASS: gdb.python/py-value.exp: print sptr +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Aquire lazy string +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: print sn +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Test lazy string +PASS: gdb.python/py-value.exp: Succesfully create a lazy string +PASS: gdb.python/py-value.exp: Test lazy string length +PASS: gdb.python/py-value.exp: Test lazy string address +PASS: gdb.python/py-value.exp: create PTR type +PASS: gdb.python/py-value.exp: kill the inferior +PASS: gdb.python/py-value.exp: Discard the symbols +PASS: gdb.python/py-value.exp: cast arg0 to PTR +PASS: gdb.python/py-value.exp: delete PTR type +PASS: gdb.python/py-value.exp: print value's type +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect pointer by reference +PASS: gdb.python/py-value.exp: Obtain address +PASS: gdb.python/py-value.exp: Obtains value from GDB +PASS: gdb.python/py-value.exp: Check pointer passed as reference +PASS: gdb.python/py-value.exp: python print (bool(gdb.parse_and_eval('base').dynamic_cast(gdb.lookup_type('Derived').pointer()))) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('base').dynamic_type) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('5').dynamic_type) +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +Running ./gdb.reverse/amd64-tailcall-reverse.exp ... +Running ./gdb.reverse/break-precsave.exp ... +Running ./gdb.reverse/break-reverse.exp ... +Running ./gdb.reverse/consecutive-precsave.exp ... +Running ./gdb.reverse/consecutive-reverse.exp ... +Running ./gdb.reverse/finish-precsave.exp ... +Running ./gdb.reverse/finish-reverse-bkpt.exp ... +Running ./gdb.reverse/finish-reverse.exp ... +Running ./gdb.reverse/i386-precsave.exp ... +Running ./gdb.reverse/i386-reverse.exp ... +Running ./gdb.reverse/i386-sse-reverse.exp ... +Running ./gdb.reverse/i387-env-reverse.exp ... +PASS: gdb.reverse/i387-env-reverse.exp: Turn on process record +FAIL: gdb.reverse/i387-env-reverse.exp: record to end of main (timeout) +FAIL: gdb.reverse/i387-env-reverse.exp: set reverse direction +FAIL: gdb.reverse/i387-env-reverse.exp: rewind to beginning of main +FAIL: gdb.reverse/i387-env-reverse.exp: set forward direction +PASS: gdb.reverse/i387-env-reverse.exp: begin testing fpu env +PASS: gdb.reverse/i387-env-reverse.exp: save FPU env in memory +PASS: gdb.reverse/i387-env-reverse.exp: restore FPU env +PASS: gdb.reverse/i387-env-reverse.exp: store status word in EAX +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +FAIL: gdb.reverse/i387-env-reverse.exp: verify eax == 0x8040000 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xffff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x3800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3fff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x3000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xfff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x2800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3ff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x2000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x1800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3f +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x1000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xf +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x7 +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x1000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xf +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x1800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3f +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x2000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x2800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3ff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x3000 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xfff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0x3800 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0x3fff +PASS: gdb.reverse/i387-env-reverse.exp: push st0 +PASS: gdb.reverse/i387-env-reverse.exp: verify fstat == 0 +PASS: gdb.reverse/i387-env-reverse.exp: verify ftag == 0xffff +Running ./gdb.reverse/i387-stack-reverse.exp ... +PASS: gdb.reverse/i387-stack-reverse.exp: Turn on process record +PASS: gdb.reverse/i387-stack-reverse.exp: record to end of main +PASS: gdb.reverse/i387-stack-reverse.exp: set reverse direction +PASS: gdb.reverse/i387-stack-reverse.exp: rewind to beginning of main +PASS: gdb.reverse/i387-stack-reverse.exp: set forward direction +PASS: gdb.reverse/i387-stack-reverse.exp: begin test st0 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 3.321928094* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 1.4426950406* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 1.4426950* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 3.3219280* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 1.44269506* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st5 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st5 == 3.32192809* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st6 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 0 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st5 == 1.44269504* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st6 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st7 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: undo registers, st0-st7 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st5 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st6 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0.69314* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st5 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 0.301029* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st4 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 3.14159265* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st3 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 1.44269504088* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 1.442695040* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st2 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 3.3219280948* +PASS: gdb.reverse/i387-stack-reverse.exp: verify st1 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: push st0 == 1 +PASS: gdb.reverse/i387-stack-reverse.exp: verify st0 == 1 +Running ./gdb.reverse/machinestate.exp ... +Running ./gdb.reverse/machinestate-precsave.exp ... +Running ./gdb.reverse/next-reverse-bkpt-over-sr.exp ... +Running ./gdb.reverse/sigall-precsave.exp ... +Running ./gdb.reverse/sigall-reverse.exp ... +Running ./gdb.reverse/singlejmp-reverse.exp ... +Running ./gdb.reverse/solib-precsave.exp ... +Running ./gdb.reverse/solib-reverse.exp ... +Running ./gdb.reverse/step-precsave.exp ... +Running ./gdb.reverse/step-reverse.exp ... +Running ./gdb.reverse/until-precsave.exp ... +Running ./gdb.reverse/until-reverse.exp ... +Running ./gdb.reverse/watch-precsave.exp ... +Running ./gdb.reverse/watch-reverse.exp ... +Running ./gdb.server/ext-attach.exp ... +Running ./gdb.server/ext-run.exp ... +PASS: gdb.server/ext-run.exp: disconnect +PASS: gdb.server/ext-run.exp: set remote exec-file +PASS: gdb.server/ext-run.exp: continue to main +PASS: gdb.server/ext-run.exp: get process list +PASS: gdb.server/ext-run.exp: kill +PASS: gdb.server/ext-run.exp: load new file without any gdbserver inferior +PASS: gdb.server/ext-run.exp: monitor exit +Running ./gdb.server/file-transfer.exp ... +PASS: gdb.server/file-transfer.exp: disconnect +FAIL: gdb.server/file-transfer.exp: put binary file +FAIL: gdb.server/file-transfer.exp: get binary file +FAIL: gdb.server/file-transfer.exp: compare binary file +FAIL: gdb.server/file-transfer.exp: deleted binary file +FAIL: gdb.server/file-transfer.exp: put text file +FAIL: gdb.server/file-transfer.exp: get text file +FAIL: gdb.server/file-transfer.exp: compare text file +FAIL: gdb.server/file-transfer.exp: deleted text file +Running ./gdb.server/no-thread-db.exp ... +PASS: gdb.server/no-thread-db.exp: successfully compiled posix threads test case +PASS: gdb.server/no-thread-db.exp: disconnect +PASS: gdb.server/no-thread-db.exp: libthread-db is now unresolvable +PASS: gdb.server/no-thread-db.exp: continue to breakpoint: after tls assignment +PASS: gdb.server/no-thread-db.exp: print foo +Running ./gdb.server/server-exec-info.exp ... +PASS: gdb.server/server-exec-info.exp: file +PASS: gdb.server/server-exec-info.exp: set sysroot remote: +PASS: gdb.server/server-exec-info.exp: info files +Running ./gdb.server/server-kill.exp ... +PASS: gdb.server/server-kill.exp: disconnect +FAIL: gdb.server/server-kill.exp: tstatus +Running ./gdb.server/server-mon.exp ... +PASS: gdb.server/server-mon.exp: disconnect +PASS: gdb.server/server-mon.exp: monitor help +PASS: gdb.server/server-mon.exp: monitor +PASS: gdb.server/server-mon.exp: monitor set debug 1 +PASS: gdb.server/server-mon.exp: monitor set debug 0 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 1 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 0 +Running ./gdb.server/server-run.exp ... +PASS: gdb.server/server-run.exp: disconnect +PASS: gdb.server/server-run.exp: loaded dynamic linker +PASS: gdb.server/server-run.exp: continue to main +Running ./gdb.server/solib-list.exp ... +Running ./gdb.stabs/exclfwd.exp ... +PASS: gdb.stabs/exclfwd.exp: ptype v1 +PASS: gdb.stabs/exclfwd.exp: ptype v2 +PASS: gdb.stabs/exclfwd.exp: ptype v3 +Running ./gdb.stabs/gdb11479.exp ... +PASS: gdb.stabs/gdb11479.exp: Set breakpoints forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: Set breakpoints natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test natural_debug_format +Running ./gdb.stabs/weird.exp ... +PASS: gdb.stabs/weird.exp: weirdx.o read without error +PASS: gdb.stabs/weird.exp: stabs found +PASS: gdb.stabs/weird.exp: variable var0 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var0) +PASS: gdb.stabs/weird.exp: variable var1 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var1) +PASS: gdb.stabs/weird.exp: variable var2 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var2) +PASS: gdb.stabs/weird.exp: variable var3 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var3) +PASS: gdb.stabs/weird.exp: variable attr32 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr32) +PASS: gdb.stabs/weird.exp: variable attr33 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr33) +PASS: gdb.stabs/weird.exp: variable attr35 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr35) +PASS: gdb.stabs/weird.exp: variable attr36 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr36) +PASS: gdb.stabs/weird.exp: variable attr37 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr37) +PASS: gdb.stabs/weird.exp: variable attr38 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr38) +PASS: gdb.stabs/weird.exp: variable attr39 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr39) +PASS: gdb.stabs/weird.exp: variable attr41 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr41) +PASS: gdb.stabs/weird.exp: variable attr42 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr42) +PASS: gdb.stabs/weird.exp: variable attr43 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr43) +PASS: gdb.stabs/weird.exp: variable attr44 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr44) +PASS: gdb.stabs/weird.exp: variable attr46 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr46) +PASS: gdb.stabs/weird.exp: variable attr47 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr47) +PASS: gdb.stabs/weird.exp: variable attr58 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr58) +PASS: gdb.stabs/weird.exp: variable attr59 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr59) +PASS: gdb.stabs/weird.exp: variable attr60 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr60) +PASS: gdb.stabs/weird.exp: variable attr61 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr61) +PASS: gdb.stabs/weird.exp: variable attr62 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr62) +PASS: gdb.stabs/weird.exp: variable attr63 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr63) +PASS: gdb.stabs/weird.exp: variable attr64 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr64) +PASS: gdb.stabs/weird.exp: variable attr65 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr65) +PASS: gdb.stabs/weird.exp: variable attr66 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr66) +PASS: gdb.stabs/weird.exp: variable attr67 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr67) +PASS: gdb.stabs/weird.exp: variable attr68 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr68) +PASS: gdb.stabs/weird.exp: variable attr69 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr69) +PASS: gdb.stabs/weird.exp: variable attr70 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr70) +PASS: gdb.stabs/weird.exp: variable attr71 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr71) +PASS: gdb.stabs/weird.exp: variable attr72 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr72) +PASS: gdb.stabs/weird.exp: variable attr73 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr73) +PASS: gdb.stabs/weird.exp: variable attr74 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr74) +PASS: gdb.stabs/weird.exp: variable attr75 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr75) +PASS: gdb.stabs/weird.exp: variable attr76 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr76) +PASS: gdb.stabs/weird.exp: variable attr77 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr77) +PASS: gdb.stabs/weird.exp: variable attr78 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr78) +PASS: gdb.stabs/weird.exp: variable attr79 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr79) +PASS: gdb.stabs/weird.exp: variable attr80 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr80) +PASS: gdb.stabs/weird.exp: variable attr81 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr81) +PASS: gdb.stabs/weird.exp: variable attr82 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr82) +PASS: gdb.stabs/weird.exp: variable attr83 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr83) +PASS: gdb.stabs/weird.exp: variable attr84 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr84) +PASS: gdb.stabs/weird.exp: variable attr85 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr85) +PASS: gdb.stabs/weird.exp: variable attr86 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr86) +PASS: gdb.stabs/weird.exp: variable attr87 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr87) +PASS: gdb.stabs/weird.exp: variable attr88 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr88) +PASS: gdb.stabs/weird.exp: variable attr89 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr89) +PASS: gdb.stabs/weird.exp: variable attr90 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr90) +PASS: gdb.stabs/weird.exp: variable attr91 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr91) +PASS: gdb.stabs/weird.exp: variable attr92 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr92) +PASS: gdb.stabs/weird.exp: variable attr93 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr93) +PASS: gdb.stabs/weird.exp: variable attr94 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr94) +PASS: gdb.stabs/weird.exp: variable attr95 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr95) +PASS: gdb.stabs/weird.exp: variable attr96 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr96) +PASS: gdb.stabs/weird.exp: variable attr97 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr97) +PASS: gdb.stabs/weird.exp: variable attr98 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr98) +PASS: gdb.stabs/weird.exp: variable attr99 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr99) +PASS: gdb.stabs/weird.exp: variable attr100 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr100) +PASS: gdb.stabs/weird.exp: variable attr101 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr101) +PASS: gdb.stabs/weird.exp: variable attr102 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr102) +PASS: gdb.stabs/weird.exp: variable attr103 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr103) +PASS: gdb.stabs/weird.exp: variable attr104 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr104) +PASS: gdb.stabs/weird.exp: variable attr105 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr105) +PASS: gdb.stabs/weird.exp: variable attr106 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr106) +PASS: gdb.stabs/weird.exp: variable attr107 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr107) +PASS: gdb.stabs/weird.exp: variable attr108 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr108) +PASS: gdb.stabs/weird.exp: variable attr109 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr109) +PASS: gdb.stabs/weird.exp: variable attr110 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr110) +PASS: gdb.stabs/weird.exp: variable attr111 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr111) +PASS: gdb.stabs/weird.exp: variable attr112 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr112) +PASS: gdb.stabs/weird.exp: variable attr113 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr113) +PASS: gdb.stabs/weird.exp: variable attr114 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr114) +PASS: gdb.stabs/weird.exp: variable attr115 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr115) +PASS: gdb.stabs/weird.exp: variable attr116 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr116) +PASS: gdb.stabs/weird.exp: variable attr117 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr117) +PASS: gdb.stabs/weird.exp: variable attr118 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr118) +PASS: gdb.stabs/weird.exp: variable attr119 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr119) +PASS: gdb.stabs/weird.exp: variable attr120 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr120) +PASS: gdb.stabs/weird.exp: variable attr121 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr121) +PASS: gdb.stabs/weird.exp: variable attr122 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr122) +PASS: gdb.stabs/weird.exp: variable attr123 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr123) +PASS: gdb.stabs/weird.exp: variable attr124 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr124) +PASS: gdb.stabs/weird.exp: variable attr125 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr125) +PASS: gdb.stabs/weird.exp: variable attr126 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr126) +PASS: gdb.stabs/weird.exp: 'e' constant on non-enum type +PASS: gdb.stabs/weird.exp: whatis const69 +PASS: gdb.stabs/weird.exp: 'e' constant with embedded type +PASS: gdb.stabs/weird.exp: char constant +PASS: gdb.stabs/weird.exp: String constant 1 +PASS: gdb.stabs/weird.exp: String constant 2 +PASS: gdb.stabs/weird.exp: String constant 3 +PASS: gdb.stabs/weird.exp: String constant 4 +PASS: gdb.stabs/weird.exp: p bad_neg0 +PASS: gdb.stabs/weird.exp: ptype on inttype +PASS: gdb.stabs/weird.exp: unrecognized floating point type +PASS: gdb.stabs/weird.exp: print very big integer +PASS: gdb.stabs/weird.exp: whatis consth +PASS: gdb.stabs/weird.exp: whatis consth2 +XFAIL: gdb.stabs/weird.exp: print struct constant +PASS: gdb.stabs/weird.exp: print bad_type0 +PASS: gdb.stabs/weird.exp: print bad_type1 +XFAIL: gdb.stabs/weird.exp: array0 with strange index +XFAIL: gdb.stabs/weird.exp: array1 with strange index +PASS: gdb.stabs/weird.exp: whatis one_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis one_var test 2 +PASS: gdb.stabs/weird.exp: whatis two_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis two_var test 2 +XFAIL: gdb.stabs/weird.exp: whatis pointer_to_int_var +XFAIL: gdb.stabs/weird.exp: whatis intp_var +PASS: gdb.stabs/weird.exp: p common0var0 +XFAIL: gdb.stabs/weird.exp: p common0var1 +XFAIL: gdb.stabs/weird.exp: p common0var2 +Running ./gdb.threads/attach-into-signal.exp ... +Running ./gdb.threads/attach-stopped.exp ... +Running ./gdb.threads/bp_in_thread.exp ... +PASS: gdb.threads/bp_in_thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/bp_in_thread.exp: breakpoint on noreturn +PASS: gdb.threads/bp_in_thread.exp: run to noreturn +Running ./gdb.threads/clone-new-thread-event.exp ... +PASS: gdb.threads/clone-new-thread-event.exp: catch SIGUSR1 +Running ./gdb.threads/corethreads.exp ... +Running ./gdb.threads/create-fail.exp ... +PASS: gdb.threads/create-fail.exp: successfully compiled posix threads test case +PASS: gdb.threads/create-fail.exp: iteration 1: run till end +PASS: gdb.threads/create-fail.exp: iteration 2: run till end +PASS: gdb.threads/create-fail.exp: iteration 3: run till end +PASS: gdb.threads/create-fail.exp: iteration 4: run till end +PASS: gdb.threads/create-fail.exp: iteration 5: run till end +PASS: gdb.threads/create-fail.exp: iteration 6: run till end +PASS: gdb.threads/create-fail.exp: iteration 7: run till end +PASS: gdb.threads/create-fail.exp: iteration 8: run till end +PASS: gdb.threads/create-fail.exp: iteration 9: run till end +PASS: gdb.threads/create-fail.exp: iteration 10: run till end +Running ./gdb.threads/current-lwp-dead.exp ... +PASS: gdb.threads/current-lwp-dead.exp: continue to breakpoint: fn_return +Running ./gdb.threads/execl.exp ... +Running ./gdb.threads/fork-child-threads.exp ... +Running ./gdb.threads/fork-thread-pending.exp ... +Running ./gdb.threads/gcore-thread.exp ... +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: help gcore +PASS: gdb.threads/gcore-thread.exp: thread 1 is running +PASS: gdb.threads/gcore-thread.exp: thread 2 is running +PASS: gdb.threads/gcore-thread.exp: save a corefile +PASS: gdb.threads/gcore-thread.exp: clear __stack_user.next +PASS: gdb.threads/gcore-thread.exp: clear stack_used.next +PASS: gdb.threads/gcore-thread.exp: save a zeroed-threads corefile +FAIL: gdb.threads/gcore-thread.exp: corefile: re-load generated corefile (bad file format) +FAIL: gdb.threads/gcore-thread.exp: core0file: re-load generated corefile (bad file format) +Running ./gdb.threads/hand-call-in-threads.exp ... +PASS: gdb.threads/hand-call-in-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on hand_call +PASS: gdb.threads/hand-call-in-threads.exp: run to all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: enable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking on +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: set confirm off +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: all dummies popped +PASS: gdb.threads/hand-call-in-threads.exp: disable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking off +Running ./gdb.threads/ia64-sigill.exp ... +PASS: gdb.threads/ia64-sigill.exp: successfully compiled posix threads test case +PASS: gdb.threads/ia64-sigill.exp: info addr label +PASS: gdb.threads/ia64-sigill.exp: set $sigill_bpnum=$bpnum +PASS: gdb.threads/ia64-sigill.exp: set debug infrun 1 +PASS: gdb.threads/ia64-sigill.exp: continue +PASS: gdb.threads/ia64-sigill.exp: delete $sigill_bpnum +PASS: gdb.threads/ia64-sigill.exp: continue for the pending signal +Running ./gdb.threads/interrupted-hand-call.exp ... +PASS: gdb.threads/interrupted-hand-call.exp: successfully compiled posix threads test case +PASS: gdb.threads/interrupted-hand-call.exp: breakpoint on all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: run to all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/interrupted-hand-call.exp: dummy stack frame present +PASS: gdb.threads/interrupted-hand-call.exp: finish hand-call +PASS: gdb.threads/interrupted-hand-call.exp: dummy frame popped +PASS: gdb.threads/interrupted-hand-call.exp: continue until exit +Running ./gdb.threads/killed.exp ... +PASS: gdb.threads/killed.exp: successfully compiled posix threads test case +PASS: gdb.threads/killed.exp: run program to completion +PASS: gdb.threads/killed.exp: GDB exits after multi-threaded program exits messily +Running ./gdb.threads/leader-exit.exp ... +PASS: gdb.threads/leader-exit.exp: successfully compiled posix threads test case +FAIL: gdb.threads/leader-exit.exp: continue to breakpoint: break-here (timeout) +FAIL: gdb.threads/leader-exit.exp: Single thread has been left (timeout) +Running ./gdb.threads/linux-dp.exp ... +PASS: gdb.threads/linux-dp.exp: successfully compiled posix threads test case +PASS: gdb.threads/linux-dp.exp: set print sevenbit-strings +PASS: gdb.threads/linux-dp.exp: info threads 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 0 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 0 +PASS: gdb.threads/linux-dp.exp: info threads after: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 1 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 1 +PASS: gdb.threads/linux-dp.exp: info threads after: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 2 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 2 +PASS: gdb.threads/linux-dp.exp: info threads after: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 3 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 3 +PASS: gdb.threads/linux-dp.exp: info threads after: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 4 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 4 +PASS: gdb.threads/linux-dp.exp: info threads after: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/linux-dp.exp: info threads 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print +PASS: gdb.threads/linux-dp.exp: first thread-specific breakpoint hit +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 5 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 6 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 7 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 8 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 9 +PASS: gdb.threads/linux-dp.exp: thread-specific breakpoint is thread-specific +PASS: gdb.threads/linux-dp.exp: selected thread: 1 +PASS: gdb.threads/linux-dp.exp: main is distinct: 1 +PASS: gdb.threads/linux-dp.exp: selected thread: 2 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 2 +PASS: gdb.threads/linux-dp.exp: selected thread: 3 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 3 +PASS: gdb.threads/linux-dp.exp: selected thread: 4 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 4 +PASS: gdb.threads/linux-dp.exp: selected thread: 5 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 5 +PASS: gdb.threads/linux-dp.exp: selected thread: 6 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 6 +PASS: gdb.threads/linux-dp.exp: found an interesting thread +PASS: gdb.threads/linux-dp.exp: manager thread found (not found) when expected +Running ./gdb.threads/local-watch-wrong-thread.exp ... +Running ./gdb.threads/manythreads.exp ... +PASS: gdb.threads/manythreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/manythreads.exp: set print sevenbit-strings +PASS: gdb.threads/manythreads.exp: shell stty intr '^C' +PASS: gdb.threads/manythreads.exp: first continue +PASS: gdb.threads/manythreads.exp: stop threads 1 +PASS: gdb.threads/manythreads.exp: info threads +PASS: gdb.threads/manythreads.exp: give a name to the thread +PASS: gdb.threads/manythreads.exp: check thread name +PASS: gdb.threads/manythreads.exp: second continue +PASS: gdb.threads/manythreads.exp: check for duplicate SIGINT +PASS: gdb.threads/manythreads.exp: stop threads 2 +PASS: gdb.threads/manythreads.exp: GDB exits after stopping multithreaded program +Running ./gdb.threads/multi-create.exp ... +PASS: gdb.threads/multi-create.exp: successfully compiled posix threads test case +PASS: gdb.threads/multi-create.exp: continue to breakpoint 0 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 1 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 2 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 3 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 4 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 5 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 6 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 7 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 8 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 9 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 10 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 11 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 12 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 13 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 14 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 15 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 16 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 17 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 18 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 19 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 20 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 21 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 22 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 23 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 24 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 25 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 26 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 27 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 28 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 29 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 30 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 31 +Running ./gdb.threads/non-ldr-exc-1.exp ... +Running ./gdb.threads/non-ldr-exc-2.exp ... +Running ./gdb.threads/non-ldr-exc-3.exp ... +Running ./gdb.threads/non-ldr-exc-4.exp ... +Running ./gdb.threads/no-unwaited-for-left.exp ... +PASS: gdb.threads/no-unwaited-for-left.exp: successfully compiled posix threads test case +PASS: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here +PASS: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for thread 2 +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when thread 2 exits (the program exited) +FAIL: gdb.threads/no-unwaited-for-left.exp: only main thread left, thread 2 terminated +PASS: gdb.threads/no-unwaited-for-left.exp: select main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: disable scheduler-locking, letting new thread start +FAIL: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here-2 +FAIL: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when the main thread exits (the program is no longer running) +FAIL: gdb.threads/no-unwaited-for-left.exp: only thread 3 left, main thread terminated +Running ./gdb.threads/pending-step.exp ... +PASS: gdb.threads/pending-step.exp: successfully compiled posix threads test case +PASS: gdb.threads/pending-step.exp: continue to breakpoint: continue to first breakpoint hit +PASS: gdb.threads/pending-step.exp: next in multiple threads with breakpoints +Running ./gdb.threads/print-threads.exp ... +PASS: gdb.threads/print-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/print-threads.exp: set print sevenbit-strings +PASS: gdb.threads/print-threads.exp: set width 0 +PASS: gdb.threads/print-threads.exp: shell stty intr '^C' +PASS: gdb.threads/print-threads.exp: break thread_function +PASS: gdb.threads/print-threads.exp: set var slow = 0 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (fast) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (fast) +PASS: gdb.threads/print-threads.exp: break thread_function (2) +PASS: gdb.threads/print-threads.exp: set var slow = 1 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow) +PASS: gdb.threads/print-threads.exp: break thread_function (3) +PASS: gdb.threads/print-threads.exp: set var slow = 1 (2) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow with kill breakpoint) +Running ./gdb.threads/pthread_cond_wait.exp ... +PASS: gdb.threads/pthread_cond_wait.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthread_cond_wait.exp: breakpoint on break_me +PASS: gdb.threads/pthread_cond_wait.exp: run to break_me +PASS: gdb.threads/pthread_cond_wait.exp: backtrace in blocked thread +Running ./gdb.threads/pthreads.exp ... +PASS: gdb.threads/pthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthreads.exp: set print sevenbit-strings +PASS: gdb.threads/pthreads.exp: set width 0 +PASS: gdb.threads/pthreads.exp: shell stty intr '^C' +PASS: gdb.threads/pthreads.exp: info threads +PASS: gdb.threads/pthreads.exp: break thread1 +PASS: gdb.threads/pthreads.exp: Continue to creation of first thread +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: break thread2 +PASS: gdb.threads/pthreads.exp: Continue to creation of second thread +PASS: gdb.threads/pthreads.exp: set var common_routine::hits=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after startup +PASS: gdb.threads/pthreads.exp: Continue with all threads running +PASS: gdb.threads/pthreads.exp: Stopped with a ^C +PASS: gdb.threads/pthreads.exp: bt +PASS: gdb.threads/pthreads.exp: set var common_routine::hits=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after continuing from ^C stop +PASS: gdb.threads/pthreads.exp: check backtrace from main thread +PASS: gdb.threads/pthreads.exp: check backtrace from thread 1 +PASS: gdb.threads/pthreads.exp: check backtrace from thread 2 +PASS: gdb.threads/pthreads.exp: apply backtrace command to all three threads +PASS: gdb.threads/pthreads.exp: set break at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: continue to bkpt at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: backtrace from thread 2 bkpt in common_routine +Running ./gdb.threads/schedlock.exp ... +PASS: gdb.threads/schedlock.exp: successfully compiled posix threads test case +PASS: gdb.threads/schedlock.exp: shell stty intr '^C' +PASS: gdb.threads/schedlock.exp: set print sevenbit-strings +PASS: gdb.threads/schedlock.exp: set width 0 +PASS: gdb.threads/schedlock.exp: scheduler locking set to none +PASS: gdb.threads/schedlock.exp: continue to breakpoint: all threads started +PASS: gdb.threads/schedlock.exp: listed args (1) +PASS: gdb.threads/schedlock.exp: continue (initial) +PASS: gdb.threads/schedlock.exp: stop all threads (initial) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (initial) +PASS: gdb.threads/schedlock.exp: listed args (2) +PASS: gdb.threads/schedlock.exp: all threads alive +PASS: gdb.threads/schedlock.exp: find current thread (1) +PASS: gdb.threads/schedlock.exp: set scheduler-locking off +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 0) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 1) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 2) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 3) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 4) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 5) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 6) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 7) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 8) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step without lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (3) +PASS: gdb.threads/schedlock.exp: current thread stepped +PASS: gdb.threads/schedlock.exp: other threads ran - unlocked +PASS: gdb.threads/schedlock.exp: set scheduler-locking on +PASS: gdb.threads/schedlock.exp: continue (with lock) +PASS: gdb.threads/schedlock.exp: stop all threads (with lock) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (with lock) +PASS: gdb.threads/schedlock.exp: find current thread (3) +PASS: gdb.threads/schedlock.exp: continue with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (4) +PASS: gdb.threads/schedlock.exp: current thread ran +PASS: gdb.threads/schedlock.exp: other threads didn't run - locked +PASS: gdb.threads/schedlock.exp: step to increment (locked 0) +PASS: gdb.threads/schedlock.exp: step to increment (locked 1) +PASS: gdb.threads/schedlock.exp: step to increment (locked 2) +PASS: gdb.threads/schedlock.exp: step to increment (locked 3) +PASS: gdb.threads/schedlock.exp: step to increment (locked 4) +PASS: gdb.threads/schedlock.exp: step to increment (locked 5) +PASS: gdb.threads/schedlock.exp: step to increment (locked 6) +PASS: gdb.threads/schedlock.exp: step to increment (locked 7) +PASS: gdb.threads/schedlock.exp: step to increment (locked 8) +PASS: gdb.threads/schedlock.exp: step to increment (locked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (5) +PASS: gdb.threads/schedlock.exp: current thread stepped locked +PASS: gdb.threads/schedlock.exp: other threads didn't run - step locked +Running ./gdb.threads/siginfo-threads.exp ... +PASS: gdb.threads/siginfo-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR1 stop print pass +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR2 stop print pass +PASS: gdb.threads/siginfo-threads.exp: get pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 0 +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 1 +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 2 +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 3 +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_pid +PASS: gdb.threads/siginfo-threads.exp: continue to breakpoint: break-at-exit +Running ./gdb.threads/sigstep-threads.exp ... +PASS: gdb.threads/sigstep-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigstep-threads.exp: handle SIGUSR1 nostop print pass +PASS: gdb.threads/sigstep-threads.exp: set scheduler-locking off +PASS: gdb.threads/sigstep-threads.exp: set $step1=$bpnum +PASS: gdb.threads/sigstep-threads.exp: continue to breakpoint: step-1 +PASS: gdb.threads/sigstep-threads.exp: disable $step1 +PASS: gdb.threads/sigstep-threads.exp: step +Running ./gdb.threads/sigthread.exp ... +PASS: gdb.threads/sigthread.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigthread.exp: handle SIGUSR1 nostop noprint pass +PASS: gdb.threads/sigthread.exp: handle SIGUSR2 nostop noprint pass +PASS: gdb.threads/sigthread.exp: continue +PASS: gdb.threads/sigthread.exp: stop with control-c +Running ./gdb.threads/staticthreads.exp ... +PASS: gdb.threads/staticthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/staticthreads.exp: set print sevenbit-strings +PASS: gdb.threads/staticthreads.exp: break sem_post +PASS: gdb.threads/staticthreads.exp: Continue to main's call of sem_post +PASS: gdb.threads/staticthreads.exp: rerun to main +PASS: gdb.threads/staticthreads.exp: handle SIG32 nostop noprint pass +PASS: gdb.threads/staticthreads.exp: handle SIG32 helps +PASS: gdb.threads/staticthreads.exp: info threads +PASS: gdb.threads/staticthreads.exp: GDB exits with static thread program +Running ./gdb.threads/switch-threads.exp ... +PASS: gdb.threads/switch-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/switch-threads.exp: continue to breakpoint: continue to thread_func +PASS: gdb.threads/switch-threads.exp: next +Running ./gdb.threads/threadapply.exp ... +PASS: gdb.threads/threadapply.exp: successfully compiled posix threads test case +PASS: gdb.threads/threadapply.exp: b 62 +PASS: gdb.threads/threadapply.exp: continue +PASS: gdb.threads/threadapply.exp: macro details +PASS: gdb.threads/threadapply.exp: defining macro +PASS: gdb.threads/threadapply.exp: set backtrace limit 3 +PASS: gdb.threads/threadapply.exp: thread apply all backthread +PASS: gdb.threads/threadapply.exp: step to the thread_function +PASS: gdb.threads/threadapply.exp: go up in the stack frame +PASS: gdb.threads/threadapply.exp: run a simple print command on all threads +PASS: gdb.threads/threadapply.exp: go down and check selected frame +Running ./gdb.threads/thread_check.exp ... +PASS: gdb.threads/thread_check.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread_check.exp: breakpoint at tf +PASS: gdb.threads/thread_check.exp: continue to tf +PASS: gdb.threads/thread_check.exp: backtrace from thread function +Running ./gdb.threads/thread_events.exp ... +Running ./gdb.threads/thread-execl.exp ... +Running ./gdb.threads/thread-find.exp ... +PASS: gdb.threads/thread-find.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-find.exp: set print sevenbit-strings +PASS: gdb.threads/thread-find.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/thread-find.exp: info threads +PASS: gdb.threads/thread-find.exp: name thread 1 +PASS: gdb.threads/thread-find.exp: name thread 2 +PASS: gdb.threads/thread-find.exp: name thread 3 +PASS: gdb.threads/thread-find.exp: name thread 4 +PASS: gdb.threads/thread-find.exp: name thread 5 +PASS: gdb.threads/thread-find.exp: name thread 6 +PASS: gdb.threads/thread-find.exp: collect thread id +PASS: gdb.threads/thread-find.exp: got thread ids +PASS: gdb.threads/thread-find.exp: collect process id +PASS: gdb.threads/thread-find.exp: collect lwp id +PASS: gdb.threads/thread-find.exp: find thread name 6 +PASS: gdb.threads/thread-find.exp: find thread name 5 +PASS: gdb.threads/thread-find.exp: find thread name 4 +PASS: gdb.threads/thread-find.exp: find thread name 3 +PASS: gdb.threads/thread-find.exp: find thread name 2 +PASS: gdb.threads/thread-find.exp: find thread name 1 +PASS: gdb.threads/thread-find.exp: find thread id 6 +PASS: gdb.threads/thread-find.exp: find thread id 5 +PASS: gdb.threads/thread-find.exp: find thread id 4 +PASS: gdb.threads/thread-find.exp: find thread id 3 +PASS: gdb.threads/thread-find.exp: find thread id 2 +PASS: gdb.threads/thread-find.exp: find thread id 1 +PASS: gdb.threads/thread-find.exp: no thread +PASS: gdb.threads/thread-find.exp: test regular exp +PASS: gdb.threads/thread-find.exp: info threads 2 4 6 +PASS: gdb.threads/thread-find.exp: info threads 3-5 +PASS: gdb.threads/thread-find.exp: test inverted range +PASS: gdb.threads/thread-find.exp: info threads 3-3 +PASS: gdb.threads/thread-find.exp: info thread foo +PASS: gdb.threads/thread-find.exp: info thread foo -1 +Running ./gdb.threads/thread-specific.exp ... +PASS: gdb.threads/thread-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-specific.exp: set print sevenbit-strings +PASS: gdb.threads/thread-specific.exp: set width 0 +PASS: gdb.threads/thread-specific.exp: thread var when not running +PASS: gdb.threads/thread-specific.exp: continue to breakpoint: all threads started +PASS: gdb.threads/thread-specific.exp: get threads list +PASS: gdb.threads/thread-specific.exp: thread var in main +PASS: gdb.threads/thread-specific.exp: breakpoint 59 main thread +PASS: gdb.threads/thread-specific.exp: continue to thread-specific breakpoint +PASS: gdb.threads/thread-specific.exp: found breakpoint for thread number +PASS: gdb.threads/thread-specific.exp: thread var at break +Running ./gdb.threads/thread-unwindonsignal.exp ... +PASS: gdb.threads/thread-unwindonsignal.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-unwindonsignal.exp: breakpoint on all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: run to all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: setting unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: showing unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/thread-unwindonsignal.exp: dummy stack frame present +PASS: gdb.threads/thread-unwindonsignal.exp: wrong thread not unwound +PASS: gdb.threads/thread-unwindonsignal.exp: finish hand-call +PASS: gdb.threads/thread-unwindonsignal.exp: dummy frame popped +PASS: gdb.threads/thread-unwindonsignal.exp: continue until exit +Running ./gdb.threads/threxit-hop-specific.exp ... +PASS: gdb.threads/threxit-hop-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/threxit-hop-specific.exp: continue to thread start +PASS: gdb.threads/threxit-hop-specific.exp: set thread specific breakpoint +PASS: gdb.threads/threxit-hop-specific.exp: get past the thread specific breakpoint +Running ./gdb.threads/tls.exp ... +PASS: gdb.threads/tls.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls.exp: set breakpoint at all threads +PASS: gdb.threads/tls.exp: set breakpoint at synch point +PASS: gdb.threads/tls.exp: set breakpoint at exit +PASS: gdb.threads/tls.exp: continue to first thread: get to thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at first th +PASS: gdb.threads/tls.exp: first thread print me +PASS: gdb.threads/tls.exp: first thread local storage +PASS: gdb.threads/tls.exp: first another thread local storage +PASS: gdb.threads/tls.exp: first info address a_thread_local +PASS: gdb.threads/tls.exp: first info address another_thread_local +PASS: gdb.threads/tls.exp: continue to second thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at second th +PASS: gdb.threads/tls.exp: second thread print me +PASS: gdb.threads/tls.exp: second thread local storage +PASS: gdb.threads/tls.exp: second another thread local storage +PASS: gdb.threads/tls.exp: second info address a_thread_local +PASS: gdb.threads/tls.exp: second info address another_thread_local +PASS: gdb.threads/tls.exp: continue to third thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at third th +PASS: gdb.threads/tls.exp: third thread print me +PASS: gdb.threads/tls.exp: third thread local storage +PASS: gdb.threads/tls.exp: third another thread local storage +PASS: gdb.threads/tls.exp: third info address a_thread_local +PASS: gdb.threads/tls.exp: third info address another_thread_local +PASS: gdb.threads/tls.exp: continue to synch point +PASS: gdb.threads/tls.exp: get number of threads +PASS: gdb.threads/tls.exp: selected thread: 1 +PASS: gdb.threads/tls.exp: backtrace of thread number 1 not relevant +PASS: gdb.threads/tls.exp: selected thread: 2 +PASS: gdb.threads/tls.exp: backtrace of thread number 2 in spin +PASS: gdb.threads/tls.exp: selected thread: 3 +PASS: gdb.threads/tls.exp: backtrace of thread number 3 in spin +PASS: gdb.threads/tls.exp: selected thread: 4 +PASS: gdb.threads/tls.exp: backtrace of thread number 4 in spin +PASS: gdb.threads/tls.exp: selected thread: 4 +PASS: gdb.threads/tls.exp: thread 4 up +PASS: gdb.threads/tls.exp: 4 thread print me +PASS: gdb.threads/tls.exp: 4 thread local storage +PASS: gdb.threads/tls.exp: 4 another thread local storage +PASS: gdb.threads/tls.exp: 4 info address a_thread_local +PASS: gdb.threads/tls.exp: 4 info address another_thread_local +PASS: gdb.threads/tls.exp: selected thread: 2 +PASS: gdb.threads/tls.exp: thread 2 up +PASS: gdb.threads/tls.exp: 2 thread print me +PASS: gdb.threads/tls.exp: 2 thread local storage +PASS: gdb.threads/tls.exp: 2 another thread local storage +PASS: gdb.threads/tls.exp: 2 info address a_thread_local +PASS: gdb.threads/tls.exp: 2 info address another_thread_local +PASS: gdb.threads/tls.exp: selected thread: 3 +PASS: gdb.threads/tls.exp: thread 3 up +PASS: gdb.threads/tls.exp: 3 thread print me +PASS: gdb.threads/tls.exp: 3 thread local storage +PASS: gdb.threads/tls.exp: 3 another thread local storage +PASS: gdb.threads/tls.exp: 3 info address a_thread_local +PASS: gdb.threads/tls.exp: 3 info address another_thread_local +PASS: gdb.threads/tls.exp: threads exited +PASS: gdb.threads/tls.exp: Expect only base thread at end +PASS: gdb.threads/tls.exp: info address a_global +PASS: gdb.threads/tls.exp: info address me +PASS: gdb.threads/tls.exp: p a_thread_local +FAIL: gdb.threads/tls.exp: p file2_thread_local +PASS: gdb.threads/tls.exp: info address file2_thread_local +PASS: gdb.threads/tls.exp: p a_thread_local second time +PASS: gdb.threads/tls.exp: info address a_thread_local +Running ./gdb.threads/tls-nodebug.exp ... +PASS: gdb.threads/tls-nodebug.exp: successfully compiled posix threads test case +FAIL: gdb.threads/tls-nodebug.exp: thread local storage +Running ./gdb.threads/tls-shared.exp ... +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-shared.exp: print thread local storage variable +PASS: gdb.threads/tls-shared.exp: ptype of thread local storage variable +PASS: gdb.threads/tls-shared.exp: print storage info for thread local storage variable +PASS: gdb.threads/tls-shared.exp: break at and of main +PASS: gdb.threads/tls-shared.exp: continue to break +PASS: gdb.threads/tls-shared.exp: print result +Running ./gdb.threads/tls-var.exp ... +PASS: gdb.threads/tls-var.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-var.exp: whatis tls_var +PASS: gdb.threads/tls-var.exp: print tls_var +Running ./gdb.threads/watchpoint-fork.exp ... +KFAIL: gdb.threads/watchpoint-fork.exp: gdbserver does not support debugging across fork (PRMS: remote/13584) +Running ./gdb.threads/watchthreads2.exp ... +Running ./gdb.threads/watchthreads.exp ... +Running ./gdb.threads/watchthreads-reorder.exp ... +Running ./gdb.trace/actions.exp ... +PASS: gdb.trace/actions.exp: 5.1a: set three tracepoints, no actions +PASS: gdb.trace/actions.exp: 5.1b: set actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.1c: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.1d: set actions for second tracepoint +PASS: gdb.trace/actions.exp: 5.1e: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.2a: set actions for last (default) tracepoint +PASS: gdb.trace/actions.exp: 5.2b: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.3a: reset actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.3b: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.4: 'end' command out of context +PASS: gdb.trace/actions.exp: 5.5a: set empty actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.5c: verify NO actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.6: actions for invalid tracepoint number +PASS: gdb.trace/actions.exp: 5.7: invalid action +PASS: gdb.trace/actions.exp: 5.8a: help actions +PASS: gdb.trace/actions.exp: 5.8b: help collect +PASS: gdb.trace/actions.exp: 5.8c: help while-stepping +PASS: gdb.trace/actions.exp: 5.8d: help end +PASS: gdb.trace/actions.exp: 5.9a: set default-collect +PASS: gdb.trace/actions.exp: 5.9b: show default-collect +PASS: gdb.trace/actions.exp: 5.9c: set default-collect +PASS: gdb.trace/actions.exp: Create a trace state variable +PASS: gdb.trace/actions.exp: 5.10a: set teval action for first tracepoint +PASS: gdb.trace/actions.exp: 5.10a: set teval action for second tracepoint +PASS: gdb.trace/actions.exp: 5.10a: verify teval actions set for two tracepoints +Running ./gdb.trace/ax.exp ... +PASS: gdb.trace/ax.exp: maint agent 12 +PASS: gdb.trace/ax.exp: maint agent gdb_char_test +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test < &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval 12 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_char_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test < &gdb_short_test +Running ./gdb.trace/backtrace.exp ... +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect regs +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect regs, args, and locals +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect stack mem cast expr +PASS: gdb.trace/backtrace.exp: run trace experiment +PASS: gdb.trace/backtrace.exp: init: make sure not debugging any trace frame +PASS: gdb.trace/backtrace.exp: 8.6: find start frame +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 1 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 2 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 4 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 5 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 6 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 7 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 9 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 10 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 11 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 12 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 14 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 15 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 16 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 17 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 19 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 1.13: trace in recursion: depth not equal to 3 +Running ./gdb.trace/change-loc.exp ... +PASS: gdb.trace/change-loc.exp: 1 trace: delete break 1 +PASS: gdb.trace/change-loc.exp: 1 trace: next +PASS: gdb.trace/change-loc.exp: 1 trace: set tracepoint on main +PASS: gdb.trace/change-loc.exp: 1 trace: breakpoint on marker +PASS: gdb.trace/change-loc.exp: 1 trace: tstart +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 1 +PASS: gdb.trace/change-loc.exp: 1 trace: set tracepoint on set_tracepoint +PASS: gdb.trace/change-loc.exp: 1 trace: set action for tracepoint +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with two locations +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 2 +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with three locations +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 3 +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with two locations (unload) +PASS: gdb.trace/change-loc.exp: 1 trace: tstop +FAIL: gdb.trace/change-loc.exp: 1 trace: tfind frame 0 +PASS: gdb.trace/change-loc.exp: 1 trace: tfind +PASS: gdb.trace/change-loc.exp: 2 trace: set pending tracepoint +PASS: gdb.trace/change-loc.exp: 2 trace: set action for tracepoint +PASS: gdb.trace/change-loc.exp: 2 trace: single pending tracepoint info (without symbols) +PASS: gdb.trace/change-loc.exp: 2 trace: tracepoint with one location +PASS: gdb.trace/change-loc.exp: 2 trace: run to main +PASS: gdb.trace/change-loc.exp: 2 trace: delete break 2 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with two locations +PASS: gdb.trace/change-loc.exp: 2 trace: breakpoint on marker +PASS: gdb.trace/change-loc.exp: 2 trace: tstart +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 1 +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 2 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with three locations +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 3 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with two locations (unload) +PASS: gdb.trace/change-loc.exp: 2 trace: tstop +PASS: gdb.trace/change-loc.exp: 2 trace: tfind frame 0 +FAIL: gdb.trace/change-loc.exp: 2 trace: tfind frame 1 +FAIL: gdb.trace/change-loc.exp: 2 trace: tfind frame 2 +PASS: gdb.trace/change-loc.exp: 2 trace: tfind +ERROR: (DejaGnu) proc "else\{" does not exist. +Running ./gdb.xml/tdesc-arch.exp ... +PASS: gdb.xml/tdesc-arch.exp: read valid architectures +PASS: gdb.xml/tdesc-arch.exp: read default architecture +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (first architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (first architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (second architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (second architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (invalid architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (invalid architecture) +Running ./gdb.xml/tdesc-errors.exp ... +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-bogus.xml +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-unknown.xml +Running ./gdb.xml/tdesc-regs.exp ... +PASS: gdb.xml/tdesc-regs.exp: set tdesc file single-reg.xml +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from extra-regs.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +PASS: gdb.xml/tdesc-regs.exp: ptype $uintreg +PASS: gdb.xml/tdesc-regs.exp: ptype $vecreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $bitfields +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from core-only.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +Running ./gdb.xml/tdesc-xinclude.exp ... +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/includes.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/bad-include.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/loop.xml + + === gdb Summary === + +# of expected passes 17663 +# of unexpected failures 251 +# of unexpected successes 1 +# of expected failures 30 +# of unknown successes 1 +# of known failures 41 +# of untested testcases 54 +# of unresolved testcases 9 +# of unsupported tests 106 +/var/tmp/portage/cross-i686-pc-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb version 7.6.1 -nw -nx -data-directory /var/tmp/portage/cross-i686-pc-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../data-directory + diff --git a/deprecated/dejagnu/gdb_baseline/x86_64-cros-linux-gnu b/deprecated/dejagnu/gdb_baseline/x86_64-cros-linux-gnu new file mode 100644 index 00000000..a9245eab --- /dev/null +++ b/deprecated/dejagnu/gdb_baseline/x86_64-cros-linux-gnu @@ -0,0 +1,19294 @@ +Test Run By yunlian on Mon Dec 16 14:52:38 2013 +Target is x86_64-cros-linux-gnu + + === gdb tests === + +Schedule of variations: + lumpy + +Running target lumpy +Running ./gdb.ada/aliased_array.exp ... +UNSUPPORTED: gdb.ada/aliased_array.exp: compilation foo.adb +Running ./gdb.ada/array_bounds.exp ... +UNSUPPORTED: gdb.ada/array_bounds.exp: compilation bar.adb +Running ./gdb.ada/arrayidx.exp ... +UNSUPPORTED: gdb.ada/arrayidx.exp: compilation p.adb +Running ./gdb.ada/arrayparam.exp ... +UNSUPPORTED: gdb.ada/arrayparam.exp: compilation foo.adb +Running ./gdb.ada/arrayptr.exp ... +UNSUPPORTED: gdb.ada/arrayptr.exp: compilation foo.adb +Running ./gdb.ada/array_return.exp ... +UNSUPPORTED: gdb.ada/array_return.exp: compilation p.adb +Running ./gdb.ada/array_subscript_addr.exp ... +UNSUPPORTED: gdb.ada/array_subscript_addr.exp: compilation p.adb +Running ./gdb.ada/assign_1.exp ... +PASS: gdb.ada/assign_1.exp: Changing the language to ada +PASS: gdb.ada/assign_1.exp: set convenience variable $xxx to 1 +Running ./gdb.ada/atomic_enum.exp ... +UNSUPPORTED: gdb.ada/atomic_enum.exp: compilation foo.adb +Running ./gdb.ada/bad-task-bp-keyword.exp ... +UNSUPPORTED: gdb.ada/bad-task-bp-keyword.exp: compilation foo.adb +Running ./gdb.ada/boolean_expr.exp ... +PASS: gdb.ada/boolean_expr.exp: Changing the language to ada +PASS: gdb.ada/boolean_expr.exp: print 1 = 2 +PASS: gdb.ada/boolean_expr.exp: print 3 = 3 +Running ./gdb.ada/bp_enum_homonym.exp ... +UNSUPPORTED: gdb.ada/bp_enum_homonym.exp: compilation p.adb +Running ./gdb.ada/bp_on_var.exp ... +UNSUPPORTED: gdb.ada/bp_on_var.exp: compilation foo.adb +Running ./gdb.ada/bp_range_type.exp ... +UNSUPPORTED: gdb.ada/bp_range_type.exp: compilation foo.adb +Running ./gdb.ada/bp_reset.exp ... +UNSUPPORTED: gdb.ada/bp_reset.exp: compilation foo.adb +Running ./gdb.ada/call_pn.exp ... +UNSUPPORTED: gdb.ada/call_pn.exp: compilation foo.adb +Running ./gdb.ada/catch_ex.exp ... +UNSUPPORTED: gdb.ada/catch_ex.exp: compilation foo.adb +Running ./gdb.ada/char_enum.exp ... +UNSUPPORTED: gdb.ada/char_enum.exp: compilation foo.adb +Running ./gdb.ada/char_param.exp ... +UNSUPPORTED: gdb.ada/char_param.exp: compilation foo.adb +Running ./gdb.ada/complete.exp ... +UNSUPPORTED: gdb.ada/complete.exp: compilation foo.adb +Running ./gdb.ada/cond_lang.exp ... +UNSUPPORTED: gdb.ada/cond_lang.exp: compilation a.adb +Running ./gdb.ada/dyn_loc.exp ... +UNSUPPORTED: gdb.ada/dyn_loc.exp: compilation p.adb +Running ./gdb.ada/enum_idx_packed.exp ... +UNSUPPORTED: gdb.ada/enum_idx_packed.exp: compilation foo.adb +Running ./gdb.ada/exec_changed.exp ... +UNTESTED: gdb.ada/exec_changed.exp: exec_changed.exp +Running ./gdb.ada/expr_delims.exp ... +UNSUPPORTED: gdb.ada/expr_delims.exp: compilation foo.adb +Running ./gdb.ada/exprs.exp ... +UNSUPPORTED: gdb.ada/exprs.exp: compilation p.adb +Running ./gdb.ada/fixed_cmp.exp ... +UNSUPPORTED: gdb.ada/fixed_cmp.exp: compilation fixed.adb +Running ./gdb.ada/fixed_points.exp ... +UNSUPPORTED: gdb.ada/fixed_points.exp: compilation fixed_points.adb +Running ./gdb.ada/formatted_ref.exp ... +UNSUPPORTED: gdb.ada/formatted_ref.exp: compilation formatted_ref.adb +UNTESTED: gdb.ada/formatted_ref.exp: formatted-ref.exp +Running ./gdb.ada/frame_args.exp ... +UNSUPPORTED: gdb.ada/frame_args.exp: compilation foo.adb +Running ./gdb.ada/fullname_bp.exp ... +UNSUPPORTED: gdb.ada/fullname_bp.exp: compilation foo.adb +Running ./gdb.ada/fun_addr.exp ... +UNSUPPORTED: gdb.ada/fun_addr.exp: compilation foo.adb +Running ./gdb.ada/funcall_param.exp ... +UNSUPPORTED: gdb.ada/funcall_param.exp: compilation foo.adb +Running ./gdb.ada/fun_in_declare.exp ... +UNSUPPORTED: gdb.ada/fun_in_declare.exp: compilation foo.adb +Running ./gdb.ada/homonym.exp ... +UNSUPPORTED: gdb.ada/homonym.exp: compilation homonym_main.adb +Running ./gdb.ada/info_locals_renaming.exp ... +UNSUPPORTED: gdb.ada/info_locals_renaming.exp: compilation foo.adb +Running ./gdb.ada/info_types.exp ... +PASS: gdb.ada/info_types.exp: set lang ada +PASS: gdb.ada/info_types.exp: info types new_integer_type +Running ./gdb.ada/int_deref.exp ... +UNSUPPORTED: gdb.ada/int_deref.exp: compilation foo.adb +Running ./gdb.ada/interface.exp ... +UNSUPPORTED: gdb.ada/interface.exp: compilation foo.adb +Running ./gdb.ada/iwide.exp ... +UNSUPPORTED: gdb.ada/iwide.exp: compilation p.adb +Running ./gdb.ada/lang_switch.exp ... +UNSUPPORTED: gdb.ada/lang_switch.exp: compilation lang_switch.adb +Running ./gdb.ada/mi_catch_ex.exp ... +UNSUPPORTED: gdb.ada/mi_catch_ex.exp: compilation foo.adb +Running ./gdb.ada/mi_task_arg.exp ... +UNSUPPORTED: gdb.ada/mi_task_arg.exp: compilation task_switch.adb +Running ./gdb.ada/mi_task_info.exp ... +UNSUPPORTED: gdb.ada/mi_task_info.exp: compilation task_switch.adb +Running ./gdb.ada/mod_from_name.exp ... +UNSUPPORTED: gdb.ada/mod_from_name.exp: compilation foo.adb +Running ./gdb.ada/nested.exp ... +UNSUPPORTED: gdb.ada/nested.exp: compilation hello.adb +Running ./gdb.ada/null_array.exp ... +UNSUPPORTED: gdb.ada/null_array.exp: compilation foo.adb +Running ./gdb.ada/null_record.exp ... +UNSUPPORTED: gdb.ada/null_record.exp: compilation null_record.adb +Running ./gdb.ada/operator_bp.exp ... +UNSUPPORTED: gdb.ada/operator_bp.exp: compilation ops_test.adb +Running ./gdb.ada/optim_drec.exp ... +UNSUPPORTED: gdb.ada/optim_drec.exp: compilation foo.adb +Running ./gdb.ada/packed_array.exp ... +UNSUPPORTED: gdb.ada/packed_array.exp: compilation pa.adb +Running ./gdb.ada/packed_tagged.exp ... +UNSUPPORTED: gdb.ada/packed_tagged.exp: compilation comp_bug.adb +Running ./gdb.ada/print_chars.exp ... +UNSUPPORTED: gdb.ada/print_chars.exp: compilation foo.adb +Running ./gdb.ada/print_pc.exp ... +UNSUPPORTED: gdb.ada/print_pc.exp: compilation dummy.adb +Running ./gdb.ada/ptr_typedef.exp ... +UNSUPPORTED: gdb.ada/ptr_typedef.exp: compilation foo.adb +Running ./gdb.ada/ptype_arith_binop.exp ... +PASS: gdb.ada/ptype_arith_binop.exp: set lang ada +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 * 2.0 +PASS: gdb.ada/ptype_arith_binop.exp: ptype 3 / 2.0 +Running ./gdb.ada/ptype_field.exp ... +UNSUPPORTED: gdb.ada/ptype_field.exp: compilation foo.adb +Running ./gdb.ada/ptype_tagged_param.exp ... +UNSUPPORTED: gdb.ada/ptype_tagged_param.exp: compilation foo.adb +Running ./gdb.ada/rdv_wait.exp ... +UNSUPPORTED: gdb.ada/rdv_wait.exp: compilation foo.adb +Running ./gdb.ada/rec_return.exp ... +UNSUPPORTED: gdb.ada/rec_return.exp: compilation foo.adb +Running ./gdb.ada/ref_param.exp ... +UNSUPPORTED: gdb.ada/ref_param.exp: compilation foo.adb +Running ./gdb.ada/ref_tick_size.exp ... +UNSUPPORTED: gdb.ada/ref_tick_size.exp: compilation p.adb +Running ./gdb.ada/same_enum.exp ... +UNSUPPORTED: gdb.ada/same_enum.exp: compilation a.adb +Running ./gdb.ada/set_pckd_arr_elt.exp ... +UNSUPPORTED: gdb.ada/set_pckd_arr_elt.exp: compilation foo.adb +Running ./gdb.ada/set_wstr.exp ... +UNSUPPORTED: gdb.ada/set_wstr.exp: compilation a.adb +Running ./gdb.ada/small_reg_param.exp ... +UNSUPPORTED: gdb.ada/small_reg_param.exp: compilation foo.adb +Running ./gdb.ada/start.exp ... +UNTESTED: gdb.ada/start.exp: start.exp +Running ./gdb.ada/str_ref_cmp.exp ... +UNSUPPORTED: gdb.ada/str_ref_cmp.exp: compilation foo.adb +Running ./gdb.ada/sym_print_name.exp ... +UNSUPPORTED: gdb.ada/sym_print_name.exp: compilation foo.adb +Running ./gdb.ada/taft_type.exp ... +UNSUPPORTED: gdb.ada/taft_type.exp: compilation p.adb +Running ./gdb.ada/tagged.exp ... +UNSUPPORTED: gdb.ada/tagged.exp: compilation foo.adb +Running ./gdb.ada/tagged_not_init.exp ... +UNSUPPORTED: gdb.ada/tagged_not_init.exp: compilation foo.adb +Running ./gdb.ada/task_bp.exp ... +UNSUPPORTED: gdb.ada/task_bp.exp: compilation foo.adb +Running ./gdb.ada/tasks.exp ... +UNSUPPORTED: gdb.ada/tasks.exp: compilation foo.adb +Running ./gdb.ada/tick_last_segv.exp ... +UNSUPPORTED: gdb.ada/tick_last_segv.exp: compilation foo.adb +Running ./gdb.ada/type_coercion.exp ... +UNSUPPORTED: gdb.ada/type_coercion.exp: compilation assign.adb +Running ./gdb.ada/unc_arr_ptr_in_var_rec.exp ... +UNSUPPORTED: gdb.ada/unc_arr_ptr_in_var_rec.exp: compilation foo.adb +Running ./gdb.ada/uninitialized_vars.exp ... +UNSUPPORTED: gdb.ada/uninitialized_vars.exp: compilation parse.adb +Running ./gdb.ada/variant_record_packed_array.exp ... +UNSUPPORTED: gdb.ada/variant_record_packed_array.exp: compilation foo.adb +Running ./gdb.ada/watch_arg.exp ... +UNSUPPORTED: gdb.ada/watch_arg.exp: compilation watch.adb +Running ./gdb.ada/whatis_array_val.exp ... +UNSUPPORTED: gdb.ada/whatis_array_val.exp: compilation foo.adb +Running ./gdb.ada/widewide.exp ... +UNSUPPORTED: gdb.ada/widewide.exp: compilation foo.adb +Running ./gdb.arch/alpha-step.exp ... +Running ./gdb.arch/altivec-abi.exp ... +Running ./gdb.arch/altivec-regs.exp ... +Running ./gdb.arch/amd64-byte.exp ... +PASS: gdb.arch/amd64-byte.exp: set first breakpoint in main +PASS: gdb.arch/amd64-byte.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/amd64-byte.exp: check contents of %al +PASS: gdb.arch/amd64-byte.exp: check contents of %bl +PASS: gdb.arch/amd64-byte.exp: check contents of %cl +PASS: gdb.arch/amd64-byte.exp: check contents of %dl +PASS: gdb.arch/amd64-byte.exp: check contents of %sil +PASS: gdb.arch/amd64-byte.exp: check contents of %dil +PASS: gdb.arch/amd64-byte.exp: check contents of %ah +PASS: gdb.arch/amd64-byte.exp: check contents of %bh +PASS: gdb.arch/amd64-byte.exp: check contents of %ch +PASS: gdb.arch/amd64-byte.exp: check contents of %dh +PASS: gdb.arch/amd64-byte.exp: set second breakpoint in main +PASS: gdb.arch/amd64-byte.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/amd64-byte.exp: check contents of %r8l +PASS: gdb.arch/amd64-byte.exp: check contents of %r9l +PASS: gdb.arch/amd64-byte.exp: check contents of %r10l +PASS: gdb.arch/amd64-byte.exp: check contents of %r11l +PASS: gdb.arch/amd64-byte.exp: check contents of %r12l +PASS: gdb.arch/amd64-byte.exp: check contents of %r13l +PASS: gdb.arch/amd64-byte.exp: check contents of %r14l +PASS: gdb.arch/amd64-byte.exp: check contents of %r15l +PASS: gdb.arch/amd64-byte.exp: set %al +PASS: gdb.arch/amd64-byte.exp: set %bl +PASS: gdb.arch/amd64-byte.exp: set %cl +PASS: gdb.arch/amd64-byte.exp: set %dl +PASS: gdb.arch/amd64-byte.exp: set %sil +PASS: gdb.arch/amd64-byte.exp: set %dil +PASS: gdb.arch/amd64-byte.exp: set %ah +PASS: gdb.arch/amd64-byte.exp: set %bh +PASS: gdb.arch/amd64-byte.exp: set %ch +PASS: gdb.arch/amd64-byte.exp: set %dh +PASS: gdb.arch/amd64-byte.exp: set third breakpoint in main +PASS: gdb.arch/amd64-byte.exp: continue to breakpoint: continue to third breakpoint in main +PASS: gdb.arch/amd64-byte.exp: check contents of %al +PASS: gdb.arch/amd64-byte.exp: check contents of %bl +PASS: gdb.arch/amd64-byte.exp: check contents of %cl +PASS: gdb.arch/amd64-byte.exp: check contents of %dl +PASS: gdb.arch/amd64-byte.exp: check contents of %sil +PASS: gdb.arch/amd64-byte.exp: check contents of %dil +PASS: gdb.arch/amd64-byte.exp: check contents of %ah +PASS: gdb.arch/amd64-byte.exp: check contents of %bh +PASS: gdb.arch/amd64-byte.exp: check contents of %ch +PASS: gdb.arch/amd64-byte.exp: check contents of %dh +PASS: gdb.arch/amd64-byte.exp: set %r8l +PASS: gdb.arch/amd64-byte.exp: set %r9l +PASS: gdb.arch/amd64-byte.exp: set %r10l +PASS: gdb.arch/amd64-byte.exp: set %r11l +PASS: gdb.arch/amd64-byte.exp: set %r12l +PASS: gdb.arch/amd64-byte.exp: set %r13l +PASS: gdb.arch/amd64-byte.exp: set %r14l +PASS: gdb.arch/amd64-byte.exp: set %r15l +PASS: gdb.arch/amd64-byte.exp: set forth breakpoint in main +PASS: gdb.arch/amd64-byte.exp: continue to breakpoint: continue to forth breakpoint in main +PASS: gdb.arch/amd64-byte.exp: check contents of %r8l +PASS: gdb.arch/amd64-byte.exp: check contents of %r9l +PASS: gdb.arch/amd64-byte.exp: check contents of %r10l +PASS: gdb.arch/amd64-byte.exp: check contents of %r11l +PASS: gdb.arch/amd64-byte.exp: check contents of %r12l +PASS: gdb.arch/amd64-byte.exp: check contents of %r13l +PASS: gdb.arch/amd64-byte.exp: check contents of %r14l +PASS: gdb.arch/amd64-byte.exp: check contents of %r15l +Running ./gdb.arch/amd64-disp-step.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /tmp/ccQtpEfb.o: requires unsupported dynamic reloc 11; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/amd64-disp-step.exp: amd64-disp-step.exp +Running ./gdb.arch/amd64-dword.exp ... +PASS: gdb.arch/amd64-dword.exp: set first breakpoint in main +PASS: gdb.arch/amd64-dword.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/amd64-dword.exp: check contents of %eax +PASS: gdb.arch/amd64-dword.exp: check contents of %ebx +PASS: gdb.arch/amd64-dword.exp: check contents of %ecx +PASS: gdb.arch/amd64-dword.exp: check contents of %edx +PASS: gdb.arch/amd64-dword.exp: check contents of %esi +PASS: gdb.arch/amd64-dword.exp: check contents of %edi +PASS: gdb.arch/amd64-dword.exp: set second breakpoint in main +PASS: gdb.arch/amd64-dword.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/amd64-dword.exp: check contents of %r8d +PASS: gdb.arch/amd64-dword.exp: check contents of %r9d +PASS: gdb.arch/amd64-dword.exp: check contents of %r10d +PASS: gdb.arch/amd64-dword.exp: check contents of %r11d +PASS: gdb.arch/amd64-dword.exp: check contents of %r12d +PASS: gdb.arch/amd64-dword.exp: check contents of %r13d +PASS: gdb.arch/amd64-dword.exp: check contents of %r14d +PASS: gdb.arch/amd64-dword.exp: check contents of %r15d +PASS: gdb.arch/amd64-dword.exp: set %eax +PASS: gdb.arch/amd64-dword.exp: set %ebx +PASS: gdb.arch/amd64-dword.exp: set %ecx +PASS: gdb.arch/amd64-dword.exp: set %edx +PASS: gdb.arch/amd64-dword.exp: set %esi +PASS: gdb.arch/amd64-dword.exp: set %edi +PASS: gdb.arch/amd64-dword.exp: set third breakpoint in main +PASS: gdb.arch/amd64-dword.exp: continue to breakpoint: continue to third breakpoint in main +PASS: gdb.arch/amd64-dword.exp: check contents of %eax +PASS: gdb.arch/amd64-dword.exp: check contents of %ebx +PASS: gdb.arch/amd64-dword.exp: check contents of %ecx +PASS: gdb.arch/amd64-dword.exp: check contents of %edx +PASS: gdb.arch/amd64-dword.exp: check contents of %esi +PASS: gdb.arch/amd64-dword.exp: check contents of %edi +PASS: gdb.arch/amd64-dword.exp: set %r8d +PASS: gdb.arch/amd64-dword.exp: set %r9d +PASS: gdb.arch/amd64-dword.exp: set %r10d +PASS: gdb.arch/amd64-dword.exp: set %r11d +PASS: gdb.arch/amd64-dword.exp: set %r12d +PASS: gdb.arch/amd64-dword.exp: set %r13d +PASS: gdb.arch/amd64-dword.exp: set %r14d +PASS: gdb.arch/amd64-dword.exp: set %r15d +PASS: gdb.arch/amd64-dword.exp: set forth breakpoint in main +PASS: gdb.arch/amd64-dword.exp: continue to breakpoint: continue to forth breakpoint in main +PASS: gdb.arch/amd64-dword.exp: check contents of %r8d +PASS: gdb.arch/amd64-dword.exp: check contents of %r9d +PASS: gdb.arch/amd64-dword.exp: check contents of %r10d +PASS: gdb.arch/amd64-dword.exp: check contents of %r11d +PASS: gdb.arch/amd64-dword.exp: check contents of %r12d +PASS: gdb.arch/amd64-dword.exp: check contents of %r13d +PASS: gdb.arch/amd64-dword.exp: check contents of %r14d +PASS: gdb.arch/amd64-dword.exp: check contents of %r15d +Running ./gdb.arch/amd64-entry-value.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.arch/amd64-entry-value0.o: requires dynamic R_X86_64_32 reloc which may overflow at runtime; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/amd64-entry-value.exp: amd64-entry-value.exp +Running ./gdb.arch/amd64-entry-value-inline.exp ... +PASS: gdb.arch/amd64-entry-value-inline.exp: continue to breakpoint: break-here +FAIL: gdb.arch/amd64-entry-value-inline.exp: p y +Running ./gdb.arch/amd64-entry-value-param.exp ... +PASS: gdb.arch/amd64-entry-value-param.exp: continue to breakpoint: break-here +FAIL: gdb.arch/amd64-entry-value-param.exp: p y +FAIL: gdb.arch/amd64-entry-value-param.exp: p b +PASS: gdb.arch/amd64-entry-value-param.exp: continue to breakpoint: break-here +FAIL: gdb.arch/amd64-entry-value-param.exp: p y +FAIL: gdb.arch/amd64-entry-value-param.exp: p b +PASS: gdb.arch/amd64-entry-value-param.exp: continue to breakpoint: break-here +FAIL: gdb.arch/amd64-entry-value-param.exp: p y +FAIL: gdb.arch/amd64-entry-value-param.exp: p b +Running ./gdb.arch/amd64-i386-address.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: cannot find -lm +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/amd64-i386-address.exp: amd64-i386-address.exp +Running ./gdb.arch/amd64-prologue-xmm.exp ... +PASS: gdb.arch/amd64-prologue-xmm.exp: continue to breakpoint: func +PASS: gdb.arch/amd64-prologue-xmm.exp: stopped at func +Running ./gdb.arch/amd64-tailcall-cxx.exp ... +FAIL: gdb.arch/amd64-tailcall-cxx.exp: bt +Running ./gdb.arch/amd64-tailcall-noret.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.arch/amd64-tailcall-noret0.o: requires dynamic R_X86_64_PC32 reloc against 'abort' which may overflow at runtime; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/amd64-tailcall-noret.exp: amd64-tailcall-noret.exp +Running ./gdb.arch/amd64-tailcall-ret.exp ... +PASS: gdb.arch/amd64-tailcall-ret.exp: continue to breakpoint: g +PASS: gdb.arch/amd64-tailcall-ret.exp: return +PASS: gdb.arch/amd64-tailcall-ret.exp: continue to breakpoint: g +PASS: gdb.arch/amd64-tailcall-ret.exp: finish +Running ./gdb.arch/amd64-word.exp ... +PASS: gdb.arch/amd64-word.exp: set first breakpoint in main +PASS: gdb.arch/amd64-word.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/amd64-word.exp: check contents of %ax +PASS: gdb.arch/amd64-word.exp: check contents of %bx +PASS: gdb.arch/amd64-word.exp: check contents of %cx +PASS: gdb.arch/amd64-word.exp: check contents of %dx +PASS: gdb.arch/amd64-word.exp: check contents of %si +PASS: gdb.arch/amd64-word.exp: check contents of %di +PASS: gdb.arch/amd64-word.exp: set second breakpoint in main +PASS: gdb.arch/amd64-word.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/amd64-word.exp: check contents of %r8w +PASS: gdb.arch/amd64-word.exp: check contents of %r9w +PASS: gdb.arch/amd64-word.exp: check contents of %r10w +PASS: gdb.arch/amd64-word.exp: check contents of %r11w +PASS: gdb.arch/amd64-word.exp: check contents of %r12w +PASS: gdb.arch/amd64-word.exp: check contents of %r13w +PASS: gdb.arch/amd64-word.exp: check contents of %r14w +PASS: gdb.arch/amd64-word.exp: check contents of %r15w +PASS: gdb.arch/amd64-word.exp: set %ax +PASS: gdb.arch/amd64-word.exp: set %bx +PASS: gdb.arch/amd64-word.exp: set %cx +PASS: gdb.arch/amd64-word.exp: set %dx +PASS: gdb.arch/amd64-word.exp: set %si +PASS: gdb.arch/amd64-word.exp: set %di +PASS: gdb.arch/amd64-word.exp: set third breakpoint in main +PASS: gdb.arch/amd64-word.exp: continue to breakpoint: continue to third breakpoint in main +PASS: gdb.arch/amd64-word.exp: check contents of %ax +PASS: gdb.arch/amd64-word.exp: check contents of %bx +PASS: gdb.arch/amd64-word.exp: check contents of %cx +PASS: gdb.arch/amd64-word.exp: check contents of %dx +PASS: gdb.arch/amd64-word.exp: check contents of %si +PASS: gdb.arch/amd64-word.exp: check contents of %di +PASS: gdb.arch/amd64-word.exp: set %r8w +PASS: gdb.arch/amd64-word.exp: set %r9w +PASS: gdb.arch/amd64-word.exp: set %r10w +PASS: gdb.arch/amd64-word.exp: set %r11w +PASS: gdb.arch/amd64-word.exp: set %r12w +PASS: gdb.arch/amd64-word.exp: set %r13w +PASS: gdb.arch/amd64-word.exp: set %r14w +PASS: gdb.arch/amd64-word.exp: set %r15w +PASS: gdb.arch/amd64-word.exp: set forth breakpoint in main +PASS: gdb.arch/amd64-word.exp: continue to breakpoint: continue to forth breakpoint in main +PASS: gdb.arch/amd64-word.exp: check contents of %r8w +PASS: gdb.arch/amd64-word.exp: check contents of %r9w +PASS: gdb.arch/amd64-word.exp: check contents of %r10w +PASS: gdb.arch/amd64-word.exp: check contents of %r11w +PASS: gdb.arch/amd64-word.exp: check contents of %r12w +PASS: gdb.arch/amd64-word.exp: check contents of %r13w +PASS: gdb.arch/amd64-word.exp: check contents of %r14w +PASS: gdb.arch/amd64-word.exp: check contents of %r15w +Running ./gdb.arch/arm-bl-branch-dest.exp ... +Running ./gdb.arch/arm-disp-step.exp ... +Running ./gdb.arch/e500-abi.exp ... +Running ./gdb.arch/e500-prologue.exp ... +Running ./gdb.arch/e500-regs.exp ... +Running ./gdb.arch/gdb1291.exp ... +Running ./gdb.arch/gdb1431.exp ... +Running ./gdb.arch/gdb1558.exp ... +Running ./gdb.arch/i386-avx.exp ... +PASS: gdb.arch/i386-avx.exp: check whether processor supports AVX +PASS: gdb.arch/i386-avx.exp: set first breakpoint in main +PASS: gdb.arch/i386-avx.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm0 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm0 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm1 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm1 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm2 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm2 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm3 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm3 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm4 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm4 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm5 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm5 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm6 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm6 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm7 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm7 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm8 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm8 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm9 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm9 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm10 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm10 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm11 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm11 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm12 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm12 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm13 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm13 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm14 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm14 +PASS: gdb.arch/i386-avx.exp: check float contents of %ymm15 +PASS: gdb.arch/i386-avx.exp: check int8 contents of %ymm15 +PASS: gdb.arch/i386-avx.exp: set %ymm0 +PASS: gdb.arch/i386-avx.exp: set %ymm1 +PASS: gdb.arch/i386-avx.exp: set %ymm2 +PASS: gdb.arch/i386-avx.exp: set %ymm3 +PASS: gdb.arch/i386-avx.exp: set %ymm4 +PASS: gdb.arch/i386-avx.exp: set %ymm5 +PASS: gdb.arch/i386-avx.exp: set %ymm6 +PASS: gdb.arch/i386-avx.exp: set %ymm7 +PASS: gdb.arch/i386-avx.exp: set %ymm8 +PASS: gdb.arch/i386-avx.exp: set %ymm9 +PASS: gdb.arch/i386-avx.exp: set %ymm10 +PASS: gdb.arch/i386-avx.exp: set %ymm11 +PASS: gdb.arch/i386-avx.exp: set %ymm12 +PASS: gdb.arch/i386-avx.exp: set %ymm13 +PASS: gdb.arch/i386-avx.exp: set %ymm14 +PASS: gdb.arch/i386-avx.exp: set %ymm15 +PASS: gdb.arch/i386-avx.exp: set second breakpoint in main +PASS: gdb.arch/i386-avx.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/i386-avx.exp: check contents of data[0] +PASS: gdb.arch/i386-avx.exp: check contents of data[1] +PASS: gdb.arch/i386-avx.exp: check contents of data[2] +PASS: gdb.arch/i386-avx.exp: check contents of data[3] +PASS: gdb.arch/i386-avx.exp: check contents of data[4] +PASS: gdb.arch/i386-avx.exp: check contents of data[5] +PASS: gdb.arch/i386-avx.exp: check contents of data[6] +PASS: gdb.arch/i386-avx.exp: check contents of data[7] +PASS: gdb.arch/i386-avx.exp: check contents of data[8] +PASS: gdb.arch/i386-avx.exp: check contents of data[9] +PASS: gdb.arch/i386-avx.exp: check contents of data[10] +PASS: gdb.arch/i386-avx.exp: check contents of data[11] +PASS: gdb.arch/i386-avx.exp: check contents of data[12] +PASS: gdb.arch/i386-avx.exp: check contents of data[13] +PASS: gdb.arch/i386-avx.exp: check contents of data[14] +PASS: gdb.arch/i386-avx.exp: check contents of data[15] +Running ./gdb.arch/i386-bp_permanent.exp ... +Running ./gdb.arch/i386-byte.exp ... +PASS: gdb.arch/i386-byte.exp: set first breakpoint in main +PASS: gdb.arch/i386-byte.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/i386-byte.exp: check contents of %al +PASS: gdb.arch/i386-byte.exp: check contents of %ah +PASS: gdb.arch/i386-byte.exp: check contents of %bl +PASS: gdb.arch/i386-byte.exp: check contents of %bh +PASS: gdb.arch/i386-byte.exp: check contents of %cl +PASS: gdb.arch/i386-byte.exp: check contents of %ch +PASS: gdb.arch/i386-byte.exp: check contents of %dl +PASS: gdb.arch/i386-byte.exp: check contents of %dh +PASS: gdb.arch/i386-byte.exp: set %al +PASS: gdb.arch/i386-byte.exp: set %ah +PASS: gdb.arch/i386-byte.exp: set %bl +PASS: gdb.arch/i386-byte.exp: set %bh +PASS: gdb.arch/i386-byte.exp: set %cl +PASS: gdb.arch/i386-byte.exp: set %ch +PASS: gdb.arch/i386-byte.exp: set %dl +PASS: gdb.arch/i386-byte.exp: set %dh +PASS: gdb.arch/i386-byte.exp: set second breakpoint in main +PASS: gdb.arch/i386-byte.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/i386-byte.exp: check contents of %al +PASS: gdb.arch/i386-byte.exp: check contents of %ah +PASS: gdb.arch/i386-byte.exp: check contents of %bl +PASS: gdb.arch/i386-byte.exp: check contents of %bh +PASS: gdb.arch/i386-byte.exp: check contents of %cl +PASS: gdb.arch/i386-byte.exp: check contents of %ch +PASS: gdb.arch/i386-byte.exp: check contents of %dl +PASS: gdb.arch/i386-byte.exp: check contents of %dh +Running ./gdb.arch/i386-cfi-notcurrent.exp ... +Running ./gdb.arch/i386-disp-step.exp ... +Running ./gdb.arch/i386-dr3-watch.exp ... +PASS: gdb.arch/i386-dr3-watch.exp: set breakpoint always-inserted on +PASS: gdb.arch/i386-dr3-watch.exp: watch i1 +PASS: gdb.arch/i386-dr3-watch.exp: watch i2 +PASS: gdb.arch/i386-dr3-watch.exp: watch i3 +PASS: gdb.arch/i386-dr3-watch.exp: watch i4 +PASS: gdb.arch/i386-dr3-watch.exp: continue to i1 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i2 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i3 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: continue to i4 watchpoint +PASS: gdb.arch/i386-dr3-watch.exp: set watchpoint occuping one debug register +PASS: gdb.arch/i386-dr3-watch.exp: watchpoint on gap1 does not fit debug registers +PASS: gdb.arch/i386-dr3-watch.exp: delete all watchpoints +PASS: gdb.arch/i386-dr3-watch.exp: watch i1 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i2 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i3 still fits +PASS: gdb.arch/i386-dr3-watch.exp: watch i4 still fits +Running ./gdb.arch/i386-float.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.arch/i386-float0.o: requires unsupported dynamic reloc 11; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/i386-float.exp: break.exp +Running ./gdb.arch/i386-gnu-cfi.exp ... +Running ./gdb.arch/i386-permbkpt.exp ... +PASS: gdb.arch/i386-permbkpt.exp: First permanent break +PASS: gdb.arch/i386-permbkpt.exp: Second permanent break +Running ./gdb.arch/i386-prologue.exp ... +Running ./gdb.arch/i386-signal.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /tmp/ccAjQh8y.o: requires unsupported dynamic reloc 11; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.arch/i386-signal.exp: i386-signal.exp +Running ./gdb.arch/i386-size.exp ... +Running ./gdb.arch/i386-size-overlap.exp ... +Running ./gdb.arch/i386-sse.exp ... +PASS: gdb.arch/i386-sse.exp: check whether processor supports SSE +PASS: gdb.arch/i386-sse.exp: set first breakpoint in main +PASS: gdb.arch/i386-sse.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm0 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm0 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm1 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm1 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm2 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm2 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm3 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm3 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm4 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm4 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm5 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm5 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm6 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm6 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm7 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm7 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm8 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm8 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm9 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm9 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm10 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm10 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm11 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm11 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm12 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm12 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm13 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm13 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm14 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm14 +PASS: gdb.arch/i386-sse.exp: check float contents of %xmm15 +PASS: gdb.arch/i386-sse.exp: check int8 contents of %xmm15 +PASS: gdb.arch/i386-sse.exp: set %xmm0 +PASS: gdb.arch/i386-sse.exp: set %xmm1 +PASS: gdb.arch/i386-sse.exp: set %xmm2 +PASS: gdb.arch/i386-sse.exp: set %xmm3 +PASS: gdb.arch/i386-sse.exp: set %xmm4 +PASS: gdb.arch/i386-sse.exp: set %xmm5 +PASS: gdb.arch/i386-sse.exp: set %xmm6 +PASS: gdb.arch/i386-sse.exp: set %xmm7 +PASS: gdb.arch/i386-sse.exp: set %xmm8 +PASS: gdb.arch/i386-sse.exp: set %xmm9 +PASS: gdb.arch/i386-sse.exp: set %xmm10 +PASS: gdb.arch/i386-sse.exp: set %xmm11 +PASS: gdb.arch/i386-sse.exp: set %xmm12 +PASS: gdb.arch/i386-sse.exp: set %xmm13 +PASS: gdb.arch/i386-sse.exp: set %xmm14 +PASS: gdb.arch/i386-sse.exp: set %xmm15 +PASS: gdb.arch/i386-sse.exp: set second breakpoint in main +PASS: gdb.arch/i386-sse.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/i386-sse.exp: check contents of data[0] +PASS: gdb.arch/i386-sse.exp: check contents of data[1] +PASS: gdb.arch/i386-sse.exp: check contents of data[2] +PASS: gdb.arch/i386-sse.exp: check contents of data[3] +PASS: gdb.arch/i386-sse.exp: check contents of data[4] +PASS: gdb.arch/i386-sse.exp: check contents of data[5] +PASS: gdb.arch/i386-sse.exp: check contents of data[6] +PASS: gdb.arch/i386-sse.exp: check contents of data[7] +PASS: gdb.arch/i386-sse.exp: check contents of data[8] +PASS: gdb.arch/i386-sse.exp: check contents of data[9] +PASS: gdb.arch/i386-sse.exp: check contents of data[10] +PASS: gdb.arch/i386-sse.exp: check contents of data[11] +PASS: gdb.arch/i386-sse.exp: check contents of data[12] +PASS: gdb.arch/i386-sse.exp: check contents of data[13] +PASS: gdb.arch/i386-sse.exp: check contents of data[14] +PASS: gdb.arch/i386-sse.exp: check contents of data[15] +Running ./gdb.arch/i386-sse-stack-align.exp ... +Running ./gdb.arch/i386-unwind.exp ... +Running ./gdb.arch/i386-word.exp ... +PASS: gdb.arch/i386-word.exp: set first breakpoint in main +PASS: gdb.arch/i386-word.exp: continue to breakpoint: continue to first breakpoint in main +PASS: gdb.arch/i386-word.exp: check contents of %ax +PASS: gdb.arch/i386-word.exp: check contents of %bx +PASS: gdb.arch/i386-word.exp: check contents of %cx +PASS: gdb.arch/i386-word.exp: check contents of %dx +PASS: gdb.arch/i386-word.exp: set %ax +PASS: gdb.arch/i386-word.exp: set %bx +PASS: gdb.arch/i386-word.exp: set %cx +PASS: gdb.arch/i386-word.exp: set %dx +PASS: gdb.arch/i386-word.exp: set second breakpoint in main +PASS: gdb.arch/i386-word.exp: continue to breakpoint: continue to second breakpoint in main +PASS: gdb.arch/i386-word.exp: check contents of %ax +PASS: gdb.arch/i386-word.exp: check contents of %bx +PASS: gdb.arch/i386-word.exp: check contents of %cx +PASS: gdb.arch/i386-word.exp: check contents of %dx +Running ./gdb.arch/ia64-breakpoint-shadow.exp ... +Running ./gdb.arch/iwmmxt-regs.exp ... +Running ./gdb.arch/mips16-thunks.exp ... +Running ./gdb.arch/mips-octeon-bbit.exp ... +Running ./gdb.arch/pa-nullify.exp ... +Running ./gdb.arch/powerpc-aix-prologue.exp ... +Running ./gdb.arch/powerpc-d128-regs.exp ... +Running ./gdb.arch/powerpc-prologue.exp ... +Running ./gdb.arch/ppc64-atomic-inst.exp ... +Running ./gdb.arch/ppc-dfp.exp ... +Running ./gdb.arch/ppc-fp.exp ... +Running ./gdb.arch/spu-info.exp ... +Running ./gdb.arch/spu-ls.exp ... +Running ./gdb.arch/system-gcore.exp ... +PASS: gdb.arch/system-gcore.exp: help gcore +PASS: gdb.arch/system-gcore.exp: set breakpoint at terminal_func +PASS: gdb.arch/system-gcore.exp: continue to terminal_func +PASS: gdb.arch/system-gcore.exp: save a corefile +FAIL: gdb.arch/system-gcore.exp: re-load generated corefile (bad file format) +Running ./gdb.arch/thumb2-it.exp ... +Running ./gdb.arch/thumb-bx-pc.exp ... +Running ./gdb.arch/thumb-prologue.exp ... +Running ./gdb.arch/thumb-singlestep.exp ... +Running ./gdb.arch/vsx-regs.exp ... +Running ./gdb.asm/asm-source.exp ... +PASS: gdb.asm/asm-source.exp: f at main +PASS: gdb.asm/asm-source.exp: next over macro +PASS: gdb.asm/asm-source.exp: step into foo2 +PASS: gdb.asm/asm-source.exp: info target +PASS: gdb.asm/asm-source.exp: info symbol +PASS: gdb.asm/asm-source.exp: list +PASS: gdb.asm/asm-source.exp: search +PASS: gdb.asm/asm-source.exp: f in foo2 +PASS: gdb.asm/asm-source.exp: n in foo2 +PASS: gdb.asm/asm-source.exp: bt ALL in foo2 +PASS: gdb.asm/asm-source.exp: bt 2 in foo2 +PASS: gdb.asm/asm-source.exp: s 2 +PASS: gdb.asm/asm-source.exp: n 2 +PASS: gdb.asm/asm-source.exp: bt 3 in foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc1.s +PASS: gdb.asm/asm-source.exp: finish from foo3 +PASS: gdb.asm/asm-source.exp: info source asmsrc2.s +PASS: gdb.asm/asm-source.exp: info sources +PASS: gdb.asm/asm-source.exp: info line +PASS: gdb.asm/asm-source.exp: next over foo3 +PASS: gdb.asm/asm-source.exp: return from foo2 +PASS: gdb.asm/asm-source.exp: look at global variable +PASS: gdb.asm/asm-source.exp: x/i &globalvar +PASS: gdb.asm/asm-source.exp: disassem &globalvar, &globalvar+1 +PASS: gdb.asm/asm-source.exp: look at static variable +PASS: gdb.asm/asm-source.exp: x/i &staticvar +PASS: gdb.asm/asm-source.exp: disassem &staticvar, &staticvar+1 +PASS: gdb.asm/asm-source.exp: look at static function +Running ./gdb.base/a2-run.exp ... +Running ./gdb.base/advance.exp ... +PASS: gdb.base/advance.exp: advance line number +PASS: gdb.base/advance.exp: malformed advance +PASS: gdb.base/advance.exp: advance func +PASS: gdb.base/advance.exp: advance function not called by current frame +PASS: gdb.base/advance.exp: set breakpoint at call to func3 +PASS: gdb.base/advance.exp: continue to call to func3 in main +PASS: gdb.base/advance.exp: advance function called as param +PASS: gdb.base/advance.exp: advance with no argument +Running ./gdb.base/alias.exp ... +PASS: gdb.base/alias.exp: alias -a set2=set +PASS: gdb.base/alias.exp: set2 print elements 42 +PASS: gdb.base/alias.exp: verify set2 +PASS: gdb.base/alias.exp: abbrev set2 not present in help command list +PASS: gdb.base/alias.exp: alias -a set3= set +PASS: gdb.base/alias.exp: set3 print elements 43 +PASS: gdb.base/alias.exp: verify set3 +PASS: gdb.base/alias.exp: abbrev set3 not present in help command list +PASS: gdb.base/alias.exp: alias -a set4 =set +PASS: gdb.base/alias.exp: set4 print elements 44 +PASS: gdb.base/alias.exp: verify set4 +PASS: gdb.base/alias.exp: abbrev set4 not present in help command list +PASS: gdb.base/alias.exp: alias -a set5 = set +PASS: gdb.base/alias.exp: set5 print elements 45 +PASS: gdb.base/alias.exp: verify set5 +PASS: gdb.base/alias.exp: abbrev set5 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- set6 = set +PASS: gdb.base/alias.exp: set6 print elements 46 +PASS: gdb.base/alias.exp: verify set6 +PASS: gdb.base/alias.exp: abbrev set6 not present in help command list +PASS: gdb.base/alias.exp: alias -a -- -a = set +PASS: gdb.base/alias.exp: -a print elements 47 +PASS: gdb.base/alias.exp: verify -a +PASS: gdb.base/alias.exp: abbrev -a not present in help command list +PASS: gdb.base/alias.exp: alias set2=set +PASS: gdb.base/alias.exp: alias foo=bar +PASS: gdb.base/alias.exp: alias spe = set p elem +PASS: gdb.base/alias.exp: spe 50 +PASS: gdb.base/alias.exp: verify spe +PASS: gdb.base/alias.exp: alias set pr elms = set p elem +PASS: gdb.base/alias.exp: set pr elms 51 +PASS: gdb.base/alias.exp: verify set pr elms +PASS: gdb.base/alias.exp: help set print +Running ./gdb.base/all-bin.exp ... +PASS: gdb.base/all-bin.exp: continuing after dummy() +PASS: gdb.base/all-bin.exp: print value of v_int+v_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int+v_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int+v_float +PASS: gdb.base/all-bin.exp: print value of v_int+v_double +PASS: gdb.base/all-bin.exp: print value of v_int<=v_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int<=v_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int<=v_float +PASS: gdb.base/all-bin.exp: print value of v_int<=v_double +PASS: gdb.base/all-bin.exp: set v_char=0 +PASS: gdb.base/all-bin.exp: set v_double=0 +PASS: gdb.base/all-bin.exp: set v_unsigned_long=0 +PASS: gdb.base/all-bin.exp: print value of v_int&&v_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_char +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_short +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_int +PASS: gdb.base/all-bin.exp: print value of v_int&&v_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_signed_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_unsigned_long +PASS: gdb.base/all-bin.exp: print value of v_int&&v_float +PASS: gdb.base/all-bin.exp: print value of v_int&&v_double +Running ./gdb.base/annota1.exp ... +Running ./gdb.base/annota3.exp ... +Running ./gdb.base/anon.exp ... +PASS: gdb.base/anon.exp: set breakpoint in anon.c +PASS: gdb.base/anon.exp: continue to breakpoint: continue to breakpoint in anon.c +PASS: gdb.base/anon.exp: print val.data.six +Running ./gdb.base/args.exp ... +Running ./gdb.base/argv0-symlink.exp ... +PASS: gdb.base/argv0-symlink.exp: kept file symbolic link name +FAIL: gdb.base/argv0-symlink.exp: kept directory symbolic link name +Running ./gdb.base/arithmet.exp ... +PASS: gdb.base/arithmet.exp: set variable x=14 +PASS: gdb.base/arithmet.exp: set variable y=2 +PASS: gdb.base/arithmet.exp: set variable z=2 +PASS: gdb.base/arithmet.exp: set variable w=3 +PASS: gdb.base/arithmet.exp: print x +PASS: gdb.base/arithmet.exp: print y +PASS: gdb.base/arithmet.exp: print z +PASS: gdb.base/arithmet.exp: print w +PASS: gdb.base/arithmet.exp: print x+y +PASS: gdb.base/arithmet.exp: print x-y +PASS: gdb.base/arithmet.exp: print x*y +PASS: gdb.base/arithmet.exp: print x/y +PASS: gdb.base/arithmet.exp: print x%y +PASS: gdb.base/arithmet.exp: print x+y+z +PASS: gdb.base/arithmet.exp: print x-y-z +PASS: gdb.base/arithmet.exp: print x*y*z +PASS: gdb.base/arithmet.exp: print x/y/z +PASS: gdb.base/arithmet.exp: print x%y%z +PASS: gdb.base/arithmet.exp: set variable x=10 +PASS: gdb.base/arithmet.exp: set variable y=4 +PASS: gdb.base/arithmet.exp: print x+y-z +PASS: gdb.base/arithmet.exp: print x+y*z +PASS: gdb.base/arithmet.exp: print x+y%w +PASS: gdb.base/arithmet.exp: print x+y/w +PASS: gdb.base/arithmet.exp: print x-y*z +PASS: gdb.base/arithmet.exp: print x-y%z +PASS: gdb.base/arithmet.exp: print x-y/z +PASS: gdb.base/arithmet.exp: print x*y/z +PASS: gdb.base/arithmet.exp: print x*y%w +PASS: gdb.base/arithmet.exp: print x/y%w +PASS: gdb.base/arithmet.exp: print x-(y+w) +PASS: gdb.base/arithmet.exp: print x/(y*w) +PASS: gdb.base/arithmet.exp: print x-(y/w) +PASS: gdb.base/arithmet.exp: print (x+y)*w +Running ./gdb.base/arrayidx.exp ... +PASS: gdb.base/arrayidx.exp: Set print array-indexes to off +PASS: gdb.base/arrayidx.exp: Print array with array-indexes off +PASS: gdb.base/arrayidx.exp: Set print array-indexes to on +PASS: gdb.base/arrayidx.exp: Print array with array-indexes on +Running ./gdb.base/assign.exp ... +PASS: gdb.base/assign.exp: continuing after dummy() +PASS: gdb.base/assign.exp: v_int=57 +PASS: gdb.base/assign.exp: set v_int to 6 +PASS: gdb.base/assign.exp: v_int+=57 +PASS: gdb.base/assign.exp: set v_int to 6 (2) +PASS: gdb.base/assign.exp: v_int-=57 +PASS: gdb.base/assign.exp: set v_int to 6 (3) +PASS: gdb.base/assign.exp: v_int*=5 +PASS: gdb.base/assign.exp: set v_int to 6 (4) +PASS: gdb.base/assign.exp: v_int/=4 +PASS: gdb.base/assign.exp: set v_int to 6 (5) +PASS: gdb.base/assign.exp: v_int%=4 +PASS: gdb.base/assign.exp: set v_int to 6 (6) +PASS: gdb.base/assign.exp: v_int+=char +PASS: gdb.base/assign.exp: set v_int to 6 (7) +PASS: gdb.base/assign.exp: v_int+=signed_char +PASS: gdb.base/assign.exp: set v_int to 6 (8) +PASS: gdb.base/assign.exp: v_int+=unsigned_char +PASS: gdb.base/assign.exp: set v_int to 6 (9) +PASS: gdb.base/assign.exp: v_int+=short +PASS: gdb.base/assign.exp: set v_int to 6 (10) +PASS: gdb.base/assign.exp: v_int+=signed_short +PASS: gdb.base/assign.exp: set v_int to 6 (11) +PASS: gdb.base/assign.exp: v_int=+unsigned_short +PASS: gdb.base/assign.exp: set v_int to 6 (12) +PASS: gdb.base/assign.exp: v_int+=signed_int +PASS: gdb.base/assign.exp: set v_int to 6 (13) +PASS: gdb.base/assign.exp: v_int+=unsigned_int +PASS: gdb.base/assign.exp: set v_int to 6 (14) +PASS: gdb.base/assign.exp: v_int+=long +PASS: gdb.base/assign.exp: set v_int to 6 (15) +PASS: gdb.base/assign.exp: v_int+=signed_long +PASS: gdb.base/assign.exp: set v_int to 6 (16) +PASS: gdb.base/assign.exp: v_int+=unsigned_long +PASS: gdb.base/assign.exp: set v_int to 6 (17) +PASS: gdb.base/assign.exp: v_int+=v_float +PASS: gdb.base/assign.exp: set v_int to 6 (18) +PASS: gdb.base/assign.exp: v_int+=double +Running ./gdb.base/async.exp ... +Running ./gdb.base/async-shell.exp ... +Running ./gdb.base/attach.exp ... +Running ./gdb.base/attach-pie-misread.exp ... +Running ./gdb.base/attach-pie-noexec.exp ... +Running ./gdb.base/attach-twice.exp ... +Running ./gdb.base/auxv.exp ... +PASS: gdb.base/auxv.exp: set print sevenbit-strings +PASS: gdb.base/auxv.exp: set width 0 +PASS: gdb.base/auxv.exp: tbreak 78 +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: info auxv on live process +PASS: gdb.base/auxv.exp: gcore +PASS: gdb.base/auxv.exp: continue +PASS: gdb.base/auxv.exp: continue +UNSUPPORTED: gdb.base/auxv.exp: generate native core dump +UNSUPPORTED: gdb.base/auxv.exp: info auxv on native core dump +UNSUPPORTED: gdb.base/auxv.exp: matching auxv data from live and core +FAIL: gdb.base/auxv.exp: load core file for info auxv on gcore-created dump +FAIL: gdb.base/auxv.exp: info auxv on gcore-created dump +FAIL: gdb.base/auxv.exp: matching auxv data from live and gcore +Running ./gdb.base/bang.exp ... +PASS: gdb.base/bang.exp: run program +Running ./gdb.base/bfp-test.exp ... +PASS: gdb.base/bfp-test.exp: continue to breakpoint: return +PASS: gdb.base/bfp-test.exp: The original value of b32 is 1.5 +PASS: gdb.base/bfp-test.exp: The original value of b64 is 2.25 +PASS: gdb.base/bfp-test.exp: The original value of b128 is 3.375 +PASS: gdb.base/bfp-test.exp: Try to change b32 to -1.5 with 'print b32=-1.5f' +PASS: gdb.base/bfp-test.exp: Try to change b64 to -2.25 with 'print b64=-2.25f' +PASS: gdb.base/bfp-test.exp: Try to change b128 to -3.375 with 'print b128=-3.375l' +PASS: gdb.base/bfp-test.exp: set variable b32 = 10.5f +PASS: gdb.base/bfp-test.exp: set variable b64 = 20.25f +PASS: gdb.base/bfp-test.exp: set variable b128 = 30.375l +PASS: gdb.base/bfp-test.exp: The value of b32 is changed to 10.5 +PASS: gdb.base/bfp-test.exp: The value of b64 is changed to 20.25 +PASS: gdb.base/bfp-test.exp: The value of b128 is changed to 30.375 +PASS: gdb.base/bfp-test.exp: set variable b32 = 100.5a +PASS: gdb.base/bfp-test.exp: set variable b64 = 200.25x +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fl +PASS: gdb.base/bfp-test.exp: set variable b128 = 300.375fff +Running ./gdb.base/bigcore.exp ... +UNTESTED: gdb.base/bigcore.exp: Remote system +Running ./gdb.base/bitfields2.exp ... +PASS: gdb.base/bitfields2.exp: set print sevenbit-strings +PASS: gdb.base/bitfields2.exp: break tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #0 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #1 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u1 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #2 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #3 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u2 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #4 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.s3 = 1 +PASS: gdb.base/bitfields2.exp: continuing to break1 #5 +PASS: gdb.base/bitfields2.exp: bitfield uniqueness; flags.u3 = 1 +PASS: gdb.base/bitfields2.exp: break tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break2 +PASS: gdb.base/bitfields2.exp: continuing to break2 #0 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u1, flags.u3, and flags.s3 to all 1s +PASS: gdb.base/bitfields2.exp: continuing to break2 #1 +PASS: gdb.base/bitfields2.exp: bitfield containment; flags.u2, flags.s1, flags.s2 to all 1s +PASS: gdb.base/bitfields2.exp: break tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break3 +PASS: gdb.base/bitfields2.exp: continuing to break3 #0 +PASS: gdb.base/bitfields2.exp: maximum unsigned bitfield values +PASS: gdb.base/bitfields2.exp: break tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break4 +PASS: gdb.base/bitfields2.exp: continuing to break4 #0 +PASS: gdb.base/bitfields2.exp: maximum signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #1 +PASS: gdb.base/bitfields2.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields2.exp: most negative signed bitfield values +PASS: gdb.base/bitfields2.exp: continuing to break4 #2 +PASS: gdb.base/bitfields2.exp: signed bitfields containing -1 +PASS: gdb.base/bitfields2.exp: break tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to tester prior to break5 +PASS: gdb.base/bitfields2.exp: continuing to break5 #0 +PASS: gdb.base/bitfields2.exp: set long long unsigned bitfield +PASS: gdb.base/bitfields2.exp: set long long signed bitfield positive +PASS: gdb.base/bitfields2.exp: long long bitfield values after set +PASS: gdb.base/bitfields2.exp: set long long signed bitfield negative +PASS: gdb.base/bitfields2.exp: long long bitfield values after set negative +Running ./gdb.base/bitfields.exp ... +PASS: gdb.base/bitfields.exp: set print sevenbit-strings +PASS: gdb.base/bitfields.exp: print flags +PASS: gdb.base/bitfields.exp: continuing to break1 #1 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s1) +PASS: gdb.base/bitfields.exp: continuing to break1 #2 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u1) +PASS: gdb.base/bitfields.exp: continuing to break1 #3 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s2) +PASS: gdb.base/bitfields.exp: continuing to break1 #4 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u2) +PASS: gdb.base/bitfields.exp: continuing to break1 #5 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s3) +PASS: gdb.base/bitfields.exp: continuing to break1 #6 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u3) +PASS: gdb.base/bitfields.exp: continuing to break1 #7 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (s9) +PASS: gdb.base/bitfields.exp: continuing to break1 #8 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (u9) +PASS: gdb.base/bitfields.exp: continuing to break1 #9 +PASS: gdb.base/bitfields.exp: bitfield uniqueness (sc) +PASS: gdb.base/bitfields.exp: bitfield containment #1 +PASS: gdb.base/bitfields.exp: continuing to break2 +PASS: gdb.base/bitfields.exp: bitfield containment #2 +PASS: gdb.base/bitfields.exp: unsigned bitfield ranges +PASS: gdb.base/bitfields.exp: signed bitfields, max positive values +PASS: gdb.base/bitfields.exp: continuing to break4 #1 +PASS: gdb.base/bitfields.exp: determining signed-ness of bitfields +PASS: gdb.base/bitfields.exp: signed bitfields, max negative values +PASS: gdb.base/bitfields.exp: continuing to break4 #2 +PASS: gdb.base/bitfields.exp: signed bitfields with -1 +PASS: gdb.base/bitfields.exp: continuing to break5 +PASS: gdb.base/bitfields.exp: distinct bitfields in container +PASS: gdb.base/bitfields.exp: print container.one.u3 +PASS: gdb.base/bitfields.exp: print container.two.u3 +PASS: gdb.base/bitfields.exp: set internal var +PASS: gdb.base/bitfields.exp: set $myvar.a = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.b = 1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.c = 0 +PASS: gdb.base/bitfields.exp: set $myvar.inner.deep.d = -1 +PASS: gdb.base/bitfields.exp: set $myvar.inner.e = 1 +PASS: gdb.base/bitfields.exp: set $myvar.f = 1 +PASS: gdb.base/bitfields.exp: print $myvar.a +PASS: gdb.base/bitfields.exp: print $myvar.inner.b +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.c +PASS: gdb.base/bitfields.exp: print $myvar.inner.deep.d +PASS: gdb.base/bitfields.exp: print $myvar.inner.e +PASS: gdb.base/bitfields.exp: print $myvar.f +Running ./gdb.base/bitops.exp ... +PASS: gdb.base/bitops.exp: print value of !1 +PASS: gdb.base/bitops.exp: print value of !0 +PASS: gdb.base/bitops.exp: print value of !100 +PASS: gdb.base/bitops.exp: print value of !1000 +PASS: gdb.base/bitops.exp: print value of !10 +PASS: gdb.base/bitops.exp: print value of !2 +PASS: gdb.base/bitops.exp: print value of 10 | 5 +PASS: gdb.base/bitops.exp: print value of 10 & 5 +PASS: gdb.base/bitops.exp: print value of 10 ^ 5 +PASS: gdb.base/bitops.exp: print value of -!0 +PASS: gdb.base/bitops.exp: print value of ~-!0 +PASS: gdb.base/bitops.exp: print value of 3 * 2 / 4.0 * 2.0 +PASS: gdb.base/bitops.exp: print value of 8 << 2 >> 4 +PASS: gdb.base/bitops.exp: print value of -1 < 0 > 1 +PASS: gdb.base/bitops.exp: print value of 15 ^ 10 ^ 5 ^ 7 +PASS: gdb.base/bitops.exp: print value of 3.5 < 4.0 +PASS: gdb.base/bitops.exp: print value of 3.5 < -4.0 +PASS: gdb.base/bitops.exp: print value of 2 > -3 +PASS: gdb.base/bitops.exp: print value of -3>4 +PASS: gdb.base/bitops.exp: print value of (-3 > 4) +PASS: gdb.base/bitops.exp: print value of 3>=2.5 +PASS: gdb.base/bitops.exp: print value of 3>=4.5 +PASS: gdb.base/bitops.exp: print value of 3==3.0 +PASS: gdb.base/bitops.exp: print value of 3==4.0 +PASS: gdb.base/bitops.exp: print value of 3!=3.0 +PASS: gdb.base/bitops.exp: print value of 3!=5.0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 > 128 >>1 +2 *2 +PASS: gdb.base/bitops.exp: print value of 1.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 1.0 +PASS: gdb.base/bitops.exp: print value of 0.0 || 0 +PASS: gdb.base/bitops.exp: print value of 0 || 1 && 0 | 0 ^ 0 == 8 +PASS: gdb.base/bitops.exp: print value of 0 == 8 > 128 >> 1 + 2 * 2 +Running ./gdb.base/break-always.exp ... +PASS: gdb.base/break-always.exp: set breakpoint always-inserted on +PASS: gdb.base/break-always.exp: confirm breakpoint always-inserted +PASS: gdb.base/break-always.exp: set breakpoint on bar +PASS: gdb.base/break-always.exp: set 2nd breakpoint on bar +PASS: gdb.base/break-always.exp: set 3rd breakpoint on bar +PASS: gdb.base/break-always.exp: set 4th breakpoint on bar +PASS: gdb.base/break-always.exp: initial check breakpoint state +PASS: gdb.base/break-always.exp: initial disable all breakpoints +PASS: gdb.base/break-always.exp: initial enable all breakpoints +PASS: gdb.base/break-always.exp: re-disable all breakpoints +PASS: gdb.base/break-always.exp: enable 3.A +PASS: gdb.base/break-always.exp: disable 3.B +PASS: gdb.base/break-always.exp: enable 3.C +PASS: gdb.base/break-always.exp: enable 2.D +PASS: gdb.base/break-always.exp: disable 2.E +PASS: gdb.base/break-always.exp: disable 3.F +PASS: gdb.base/break-always.exp: enable 3.G +PASS: gdb.base/break-always.exp: enable 2.H +PASS: gdb.base/break-always.exp: disable 2.I +PASS: gdb.base/break-always.exp: before re-enable check breakpoint state +PASS: gdb.base/break-always.exp: re-enable all breakpoints +PASS: gdb.base/break-always.exp: set breakpoint on bar 2 +PASS: gdb.base/break-always.exp: save shadow +PASS: gdb.base/break-always.exp: write 0 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 0 from the breakpoint's address +PASS: gdb.base/break-always.exp: write 1 to breakpoint's address +PASS: gdb.base/break-always.exp: read back 1 from the breakpoint's address +PASS: gdb.base/break-always.exp: p /x *(char *) 0x55555555470c = $shadow +PASS: gdb.base/break-always.exp: continue to breakpoint: bar +Running ./gdb.base/break-caller-line.exp ... +PASS: gdb.base/break-caller-line.exp: up +PASS: gdb.base/break-caller-line.exp: info line *$pc +PASS: gdb.base/break-caller-line.exp: break +Running ./gdb.base/break-entry.exp ... +UNTESTED: gdb.base/break-entry.exp: break-entry.exp +Running ./gdb.base/break.exp ... +PASS: gdb.base/break.exp: Delete all breakpoints when none +PASS: gdb.base/break.exp: breakpoint function +PASS: gdb.base/break.exp: breakpoint quoted function +PASS: gdb.base/break.exp: breakpoint function in file +PASS: gdb.base/break.exp: use `list' to establish default source file +PASS: gdb.base/break.exp: breakpoint line number +PASS: gdb.base/break.exp: breakpoint duplicate +PASS: gdb.base/break.exp: breakpoint line number in file +PASS: gdb.base/break.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/break.exp: breakpoint at start of multi line while conditional +PASS: gdb.base/break.exp: breakpoint info +PASS: gdb.base/break.exp: info break 2 4 6 +PASS: gdb.base/break.exp: info break 3-5 +PASS: gdb.base/break.exp: disable using history values +PASS: gdb.base/break.exp: check disable with history values +PASS: gdb.base/break.exp: disable with convenience values +PASS: gdb.base/break.exp: check disable with convenience values +PASS: gdb.base/break.exp: disable non-existent breakpoint 10 +PASS: gdb.base/break.exp: set $baz 1.234 +PASS: gdb.base/break.exp: disable with non-integer convenience var +PASS: gdb.base/break.exp: disable with non-existent convenience var +PASS: gdb.base/break.exp: disable with non-existent history value +PASS: gdb.base/break.exp: disable with badly formed history value +PASS: gdb.base/break.exp: run until function breakpoint +PASS: gdb.base/break.exp: list marker1 +PASS: gdb.base/break.exp: break lineno +PASS: gdb.base/break.exp: delete $bpnum +PASS: gdb.base/break.exp: run until breakpoint set at a line number +PASS: gdb.base/break.exp: run until file:function(6) breakpoint +PASS: gdb.base/break.exp: run until file:function(5) breakpoint +PASS: gdb.base/break.exp: run until file:function(4) breakpoint +PASS: gdb.base/break.exp: run until file:function(3) breakpoint +PASS: gdb.base/break.exp: run until file:function(2) breakpoint +PASS: gdb.base/break.exp: run until file:function(1) breakpoint +PASS: gdb.base/break.exp: run until quoted breakpoint +PASS: gdb.base/break.exp: run until file:linenum breakpoint +PASS: gdb.base/break.exp: breakpoint offset +1 +PASS: gdb.base/break.exp: step onto breakpoint +PASS: gdb.base/break.exp: setting breakpoint at } +PASS: gdb.base/break.exp: continue to breakpoint at } +PASS: gdb.base/break.exp: Temporary breakpoint function +PASS: gdb.base/break.exp: Temporary breakpoint function in file +PASS: gdb.base/break.exp: Temporary breakpoint line number #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number #2 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/break.exp: Temporary breakpoint line number in file #2 +PASS: gdb.base/break.exp: Temporary breakpoint info +PASS: gdb.base/break.exp: catch requires an event name +PASS: gdb.base/break.exp: set catch fork, never expected to trigger +PASS: gdb.base/break.exp: set catch vfork, never expected to trigger +PASS: gdb.base/break.exp: set catch exec, never expected to trigger +PASS: gdb.base/break.exp: set breakpoint pending off +PASS: gdb.base/break.exp: break on non-existent source line +PASS: gdb.base/break.exp: until bp_location1 +PASS: gdb.base/break.exp: break on default location, 1st time +PASS: gdb.base/break.exp: break on default location, 2nd time +PASS: gdb.base/break.exp: break on default location, 3rd time +PASS: gdb.base/break.exp: break on default location, 4th time +PASS: gdb.base/break.exp: set to-be-silent break bp_location1 +PASS: gdb.base/break.exp: set silent break bp_location1 +PASS: gdb.base/break.exp: info silent break bp_location1 +PASS: gdb.base/break.exp: hit silent break bp_location1 +PASS: gdb.base/break.exp: stopped for silent break bp_location1 +PASS: gdb.base/break.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/break.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/break.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/break.exp: step over breakpoint +PASS: gdb.base/break.exp: clear line has no breakpoint disallowed +PASS: gdb.base/break.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/break.exp: break marker3 #1 +PASS: gdb.base/break.exp: break marker3 #2 +PASS: gdb.base/break.exp: clear marker3 +PASS: gdb.base/break.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/break.exp: set breakpoint via convenience variable +PASS: gdb.base/break.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/break.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/break.exp: set breakpoint on to-be-called function +PASS: gdb.base/break.exp: hit breakpoint on called function +PASS: gdb.base/break.exp: backtrace while in called function +PASS: gdb.base/break.exp: finish from called function +PASS: gdb.base/break.exp: finish with arguments disallowed +PASS: gdb.base/break.exp: finish from outermost frame disallowed +PASS: gdb.base/break.exp: kill program +PASS: gdb.base/break.exp: break at factorial +PASS: gdb.base/break.exp: continue to factorial(5) +PASS: gdb.base/break.exp: backtrace from factorial(5) +PASS: gdb.base/break.exp: next to recursive call +PASS: gdb.base/break.exp: next over recursive call +PASS: gdb.base/break.exp: backtrace from factorial(5.1) +PASS: gdb.base/break.exp: continue until exit at recursive next test +PASS: gdb.base/break.exp: breakpoint function, optimized file +PASS: gdb.base/break.exp: breakpoint small function, optimized file +PASS: gdb.base/break.exp: run until function breakpoint, optimized file (code motion) +PASS: gdb.base/break.exp: run until breakpoint set at small function, optimized file +PASS: gdb.base/break.exp: rbreak junk pending setup +PASS: gdb.base/break.exp: rbreak junk set breakpoint +PASS: gdb.base/break.exp: rbreak junk +Running ./gdb.base/break-inline.exp ... +PASS: gdb.base/break-inline.exp: break +Running ./gdb.base/break-interp.exp ... +Running ./gdb.base/break-on-linker-gcd-function.exp ... +PASS: gdb.base/break-on-linker-gcd-function.exp: b 25 +Running ./gdb.base/breakpoint-shadow.exp ... +PASS: gdb.base/breakpoint-shadow.exp: set breakpoint always-inserted on +PASS: gdb.base/breakpoint-shadow.exp: show breakpoint always-inserted +PASS: gdb.base/breakpoint-shadow.exp: disassembly without breakpoints +PASS: gdb.base/breakpoint-shadow.exp: First breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: Second breakpoint placed +PASS: gdb.base/breakpoint-shadow.exp: disassembly with breakpoints +Running ./gdb.base/call-ar-st.exp ... +PASS: gdb.base/call-ar-st.exp: set print sevenbit-strings +PASS: gdb.base/call-ar-st.exp: set print address off +PASS: gdb.base/call-ar-st.exp: set width 0 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1209 +PASS: gdb.base/call-ar-st.exp: run until breakpoint set at a line +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1216 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1220 +PASS: gdb.base/call-ar-st.exp: step inside print_all_arrays +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1236 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1241 +PASS: gdb.base/call-ar-st.exp: continue to 1241 +PASS: gdb.base/call-ar-st.exp: set breakpoint in sum_array_print +PASS: gdb.base/call-ar-st.exp: set print frame-arguments all +PASS: gdb.base/call-ar-st.exp: check args of sum_array_print +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1281 +PASS: gdb.base/call-ar-st.exp: print compute_with_small_structs(20) +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1286 +PASS: gdb.base/call-ar-st.exp: continue to 1286 +PASS: gdb.base/call-ar-st.exp: tbreak in print_long_arg_list after stepping into memcpy +PASS: gdb.base/call-ar-st.exp: step into print_long_arg_list +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1300 +PASS: gdb.base/call-ar-st.exp: step into init_bit_flags_combo +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1305 +PASS: gdb.base/call-ar-st.exp: continue to 1305 +PASS: gdb.base/call-ar-st.exp: tbreakpoint line 1311 +PASS: gdb.base/call-ar-st.exp: continue to 1311 +Running ./gdb.base/callexit.exp ... +PASS: gdb.base/callexit.exp: inferior function call terminated program +Running ./gdb.base/callfuncs.exp ... +PASS: gdb.base/callfuncs.exp: set print sevenbit-strings +PASS: gdb.base/callfuncs.exp: set print address off +PASS: gdb.base/callfuncs.exp: set width 0 +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: set unwindonsignal on +PASS: gdb.base/callfuncs.exp: p t_char_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_char_values('a','b') +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values('a',char_val2) +PASS: gdb.base/callfuncs.exp: p t_char_values(char_val1,'b') +PASS: gdb.base/callfuncs.exp: p t_short_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,-23) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(10,short_val2) +PASS: gdb.base/callfuncs.exp: p t_short_values(short_val1,-23) +PASS: gdb.base/callfuncs.exp: p t_int_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,-26) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(87,int_val2) +PASS: gdb.base/callfuncs.exp: p t_int_values(int_val1,-26) +PASS: gdb.base/callfuncs.exp: p t_long_values(0,0) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,-321) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(789,long_val2) +PASS: gdb.base/callfuncs.exp: p t_long_values(long_val1,-321) +PASS: gdb.base/callfuncs.exp: p t_float_values(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_float_values(3.14159,-2.3765) +PASS: gdb.base/callfuncs.exp: p t_float_values(float_val1,float_val2) +PASS: gdb.base/callfuncs.exp: p t_float_values(3.14159,float_val2) +PASS: gdb.base/callfuncs.exp: p t_float_values(float_val1,-2.3765) +PASS: gdb.base/callfuncs.exp: p t_float_values2(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_float_values2(3.14159,float_val2) +PASS: gdb.base/callfuncs.exp: Call function with many float arguments. +PASS: gdb.base/callfuncs.exp: p t_small_values(1,2,3,4,5,6,7,8,9,10) +PASS: gdb.base/callfuncs.exp: p t_double_values(0.0,0.0) +PASS: gdb.base/callfuncs.exp: p t_double_values(45.654,-67.66) +PASS: gdb.base/callfuncs.exp: p t_double_values(double_val1,double_val2) +PASS: gdb.base/callfuncs.exp: p t_double_values(45.654,double_val2) +PASS: gdb.base/callfuncs.exp: p t_double_values(double_val1,-67.66) +PASS: gdb.base/callfuncs.exp: Call function with many double arguments. +PASS: gdb.base/callfuncs.exp: p t_double_int(99.0, 1) +PASS: gdb.base/callfuncs.exp: p t_double_int(99.0, 99) +PASS: gdb.base/callfuncs.exp: p t_int_double(99, 1.0) +PASS: gdb.base/callfuncs.exp: p t_int_double(99, 99.0) +PASS: gdb.base/callfuncs.exp: p t_float_complex_values(fc1, fc2) +PASS: gdb.base/callfuncs.exp: p t_float_complex_values(fc3, fc4) +PASS: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4, fc1, fc2, fc3, fc4) +PASS: gdb.base/callfuncs.exp: p t_float_complex_many_args(fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1, fc1) +PASS: gdb.base/callfuncs.exp: p t_double_complex_values(dc1, dc2) +PASS: gdb.base/callfuncs.exp: p t_double_complex_values(dc3, dc4) +PASS: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4, dc1, dc2, dc3, dc4) +PASS: gdb.base/callfuncs.exp: p t_double_complex_many_args(dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1, dc1) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc1, ldc2) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_values(ldc3, ldc4) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4, ldc1, ldc2, ldc3, ldc4) +PASS: gdb.base/callfuncs.exp: p t_long_double_complex_many_args(ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1,ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1, ldc1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val2,string_val1) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val1,string_val2) +PASS: gdb.base/callfuncs.exp: p t_string_values("string 1","string 2") +PASS: gdb.base/callfuncs.exp: p t_string_values("string 1",string_val2) +PASS: gdb.base/callfuncs.exp: p t_string_values(string_val1,"string 2") +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val2,char_array_val1) +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,char_array_val2) +PASS: gdb.base/callfuncs.exp: p t_char_array_values("carray 1","carray 2") +PASS: gdb.base/callfuncs.exp: p t_char_array_values("carray 1",char_array_val2) +PASS: gdb.base/callfuncs.exp: p t_char_array_values(char_array_val1,"carray 2") +PASS: gdb.base/callfuncs.exp: p doubleit(4) +PASS: gdb.base/callfuncs.exp: p add(4,5) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val2,func_val1) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,func_val2) +PASS: gdb.base/callfuncs.exp: p function_struct.func(5) +PASS: gdb.base/callfuncs.exp: p function_struct_ptr->func(10) +PASS: gdb.base/callfuncs.exp: p t_func_values(add,func_val2) +PASS: gdb.base/callfuncs.exp: p t_func_values(func_val1,doubleit) +PASS: gdb.base/callfuncs.exp: p t_call_add(add,3,4) +PASS: gdb.base/callfuncs.exp: p t_call_add(func_val1,3,4) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enumval1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val1) +PASS: gdb.base/callfuncs.exp: p t_enum_value1(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enumval2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val2) +PASS: gdb.base/callfuncs.exp: p t_enum_value2(enum_val1) +PASS: gdb.base/callfuncs.exp: p sum_args(1,{2}) +PASS: gdb.base/callfuncs.exp: p sum_args(2,{2,3}) +PASS: gdb.base/callfuncs.exp: p sum_args(3,{2,3,4}) +PASS: gdb.base/callfuncs.exp: p sum_args(4,{2,3,4,5}) +PASS: gdb.base/callfuncs.exp: p sum10 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) +PASS: gdb.base/callfuncs.exp: p cmp10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns short +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns int +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns float +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns double +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns float _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns long double _Complex +PASS: gdb.base/callfuncs.exp: call inferior func with struct - returns char * +PASS: gdb.base/callfuncs.exp: set unwindonsignal off +PASS: gdb.base/callfuncs.exp: register contents after gdb function calls +PASS: gdb.base/callfuncs.exp: gdb function calls preserve register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at breakpoint in call dummy function +PASS: gdb.base/callfuncs.exp: continue from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: bt after continuing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after stop in call dummy +PASS: gdb.base/callfuncs.exp: continue after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint then do a finish +PASS: gdb.base/callfuncs.exp: finish from call dummy breakpoint returns correct value +PASS: gdb.base/callfuncs.exp: bt after finishing from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after finish in call dummy +PASS: gdb.base/callfuncs.exp: finish after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: call function causing a breakpoint and then do a return +PASS: gdb.base/callfuncs.exp: back at main after return from call dummy breakpoint +PASS: gdb.base/callfuncs.exp: register contents after return in call dummy +PASS: gdb.base/callfuncs.exp: return after stop in call dummy preserves register contents +PASS: gdb.base/callfuncs.exp: set language c +PASS: gdb.base/callfuncs.exp: next to t_double_values +PASS: gdb.base/callfuncs.exp: next to t_structs_c +PASS: gdb.base/callfuncs.exp: retrieve original register contents +PASS: gdb.base/callfuncs.exp: stop at nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 1 +PASS: gdb.base/callfuncs.exp: stop at nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 2 +PASS: gdb.base/callfuncs.exp: stop at nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 3 +PASS: gdb.base/callfuncs.exp: stop at nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace at nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 4 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 3 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 2 +PASS: gdb.base/callfuncs.exp: Finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: backtrace after finish from nested call level 1 +PASS: gdb.base/callfuncs.exp: register contents after nested call dummies +PASS: gdb.base/callfuncs.exp: nested call dummies preserve register contents +PASS: gdb.base/callfuncs.exp: set $old_sp = $sp +PASS: gdb.base/callfuncs.exp: set $sp = 0 +PASS: gdb.base/callfuncs.exp: sp == 0: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = -1 +PASS: gdb.base/callfuncs.exp: sp == -1: call doubleit (1) +PASS: gdb.base/callfuncs.exp: set $sp = $old_sp +PASS: gdb.base/callfuncs.exp: print callfunc (Lcallfunc, 5) +PASS: gdb.base/callfuncs.exp: print *((int *(*) (void)) voidfunc)() +Running ./gdb.base/call-rt-st.exp ... +PASS: gdb.base/call-rt-st.exp: set print sevenbit-strings +PASS: gdb.base/call-rt-st.exp: set print address off +PASS: gdb.base/call-rt-st.exp: set width 0 +PASS: gdb.base/call-rt-st.exp: breakpoint loop_count +PASS: gdb.base/call-rt-st.exp: continue to loop_count +PASS: gdb.base/call-rt-st.exp: finish out from loop_count (line 777) +Running ./gdb.base/call-sc.exp ... +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tc (char) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tc char +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tc +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tc +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tc +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tc +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tc +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tc +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tc +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ts (short int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ts short int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ts +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ts +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ts +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ts +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ts +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ts +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ts +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-ti (int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-ti int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-ti +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-ti +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-ti +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-ti +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-ti +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-ti +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-ti +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tl (long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tl long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tl +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tl +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tl +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tl +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tl +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tl +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tl +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tll (long long int) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tll long long int +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tll +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tll +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tll +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tll +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tll +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tll +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tll +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tf (float) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tf float +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tf +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tf +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tf +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tf +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tf +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tf +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tf +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-td (double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-td double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-td +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-td +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; return call-sc-td +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-td +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-td +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-td +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-td +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-td +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-tld (long double) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-tld long double +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-tld +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-tld +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-tld +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-tld +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-tld +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-tld +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-tld +PASS: gdb.base/call-sc.exp: set print sevenbit-strings +PASS: gdb.base/call-sc.exp: set print address off +PASS: gdb.base/call-sc.exp: set width 0 +PASS: gdb.base/call-sc.exp: ptype; call-sc-te (enum {e = 49}) +PASS: gdb.base/call-sc.exp: ptype foo; call-sc-te enum {e = 49} +PASS: gdb.base/call-sc.exp: p/c fun(); call call-sc-te +PASS: gdb.base/call-sc.exp: call Fun(foo); call call-sc-te +PASS: gdb.base/call-sc.exp: p/c L; call call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for return; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for return; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; return call-sc-te +PASS: gdb.base/call-sc.exp: return foo; synchronize pc to main() +PASS: gdb.base/call-sc.exp: value foo returned; return call-sc-te +PASS: gdb.base/call-sc.exp: advance to fun for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: zed L for finish; return call-sc-te +PASS: gdb.base/call-sc.exp: finish foo; return call-sc-te +PASS: gdb.base/call-sc.exp: value foo finished; return call-sc-te +PASS: gdb.base/call-sc.exp: return and finish use same convention; return call-sc-te +Running ./gdb.base/call-signal-resume.exp ... +Running ./gdb.base/call-strs.exp ... +PASS: gdb.base/call-strs.exp: set print sevenbit-strings +PASS: gdb.base/call-strs.exp: set print address off +PASS: gdb.base/call-strs.exp: set print symbol off +PASS: gdb.base/call-strs.exp: set width 0 +PASS: gdb.base/call-strs.exp: step after assignment to s +PASS: gdb.base/call-strs.exp: next over strcpy +PASS: gdb.base/call-strs.exp: print buf +PASS: gdb.base/call-strs.exp: print s +Running ./gdb.base/catch-load.exp ... +PASS: gdb.base/catch-load.exp: plain load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain load: catch load +PASS: gdb.base/catch-load.exp: plain load: continue +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: catch load +PASS: gdb.base/catch-load.exp: plain load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: rx load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx load: catch load catch-load-so +PASS: gdb.base/catch-load.exp: rx load: continue +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: catch load catch-load-so +PASS: gdb.base/catch-load.exp: rx load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: non-matching load: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching load: catch load zardoz +PASS: gdb.base/catch-load.exp: non-matching load: continue +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: catch load zardoz +PASS: gdb.base/catch-load.exp: non-matching load with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: plain unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: plain unload: catch unload +PASS: gdb.base/catch-load.exp: plain unload: continue +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: catch unload +PASS: gdb.base/catch-load.exp: plain unload with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: rx unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: rx unload: catch unload catch-load-so +PASS: gdb.base/catch-load.exp: rx unload: continue +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: catch unload catch-load-so +PASS: gdb.base/catch-load.exp: rx unload with stop-on-solib-events: continue +PASS: gdb.base/catch-load.exp: non-matching unload: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload: set stop-on-solib-events 0 +PASS: gdb.base/catch-load.exp: non-matching unload: catch unload zardoz +PASS: gdb.base/catch-load.exp: non-matching unload: continue +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set var libname = "catch-load-so.so" +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: set stop-on-solib-events 1 +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: catch unload zardoz +PASS: gdb.base/catch-load.exp: non-matching unload with stop-on-solib-events: continue +Running ./gdb.base/catch-signal.exp ... +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGHUP +PASS: gdb.base/catch-signal.exp: SIGHUP: continue +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: 1: catch signal 1 +PASS: gdb.base/catch-signal.exp: 1: continue +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: 1: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: 1: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: 1: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: 1: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: first HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: handle marker +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: second HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGHUP SIGUSR2 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: third HUP +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGUSR1 nostop noprint pass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: catch signal SIGUSR1 +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: handle SIGHUP nostop noprint nopass +PASS: gdb.base/catch-signal.exp: SIGHUP SIGUSR2: continue to breakpoint: fourth HUP +PASS: gdb.base/catch-signal.exp: catch signal SIGZARDOZ +PASS: gdb.base/catch-signal.exp: catch signal all +PASS: gdb.base/catch-signal.exp: catch signal all SIGHUP +PASS: gdb.base/catch-signal.exp: catch signal SIGHUP all +PASS: gdb.base/catch-signal.exp: set catchpoint '' for printing +PASS: gdb.base/catch-signal.exp: info break for '' +PASS: gdb.base/catch-signal.exp: save breakpoints for '' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for '' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP' +PASS: gdb.base/catch-signal.exp: set catchpoint 'SIGHUP SIGUSR2' for printing +PASS: gdb.base/catch-signal.exp: info break for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'SIGHUP SIGUSR2' +PASS: gdb.base/catch-signal.exp: set catchpoint 'all' for printing +PASS: gdb.base/catch-signal.exp: info break for 'all' +PASS: gdb.base/catch-signal.exp: save breakpoints for 'all' +PASS: gdb.base/catch-signal.exp: results of save breakpoints for 'all' +Running ./gdb.base/catch-syscall.exp ... +Running ./gdb.base/charset.exp ... +PASS: gdb.base/charset.exp: show charset +PASS: gdb.base/charset.exp: show target-charset +PASS: gdb.base/charset.exp: check `show target-charset' against `show charset' +PASS: gdb.base/charset.exp: show host-charset +PASS: gdb.base/charset.exp: check `show host-charset' against `show charset' +PASS: gdb.base/charset.exp: try malformed `set charset' +PASS: gdb.base/charset.exp: try `set host-charset' with invalid charset +PASS: gdb.base/charset.exp: try `set target-charset' with invalid charset +PASS: gdb.base/charset.exp: capture valid host charsets +PASS: gdb.base/charset.exp: capture valid target charsets +PASS: gdb.base/charset.exp: try `set host-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set host-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set host-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set host-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: try `set host-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set host-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set host-charset IBM1047' +PASS: gdb.base/charset.exp: try `set target-charset ASCII' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ASCII' +PASS: gdb.base/charset.exp: check effect of `set target-charset ASCII' +PASS: gdb.base/charset.exp: try `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: check effect of `set target-charset ISO-8859-1' +PASS: gdb.base/charset.exp: try `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: check effect of `set target-charset EBCDIC-US' +PASS: gdb.base/charset.exp: try `set target-charset IBM1047' +PASS: gdb.base/charset.exp: parse `show charset' after `set target-charset IBM1047' +PASS: gdb.base/charset.exp: check effect of `set target-charset IBM1047' +PASS: gdb.base/charset.exp: set breakpoint after all strings have been initialized +PASS: gdb.base/charset.exp: run until all strings have been initialized +PASS: gdb.base/charset.exp: get integer valueof "sizeof (wchar_t)" (4) +PASS: gdb.base/charset.exp: set host-charset ASCII +PASS: gdb.base/charset.exp: set target-charset ASCII +PASS: gdb.base/charset.exp: print the null character in ASCII +PASS: gdb.base/charset.exp: print string in ASCII +PASS: gdb.base/charset.exp: parse character literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed character literal in ASCII +PASS: gdb.base/charset.exp: parse string literal in ASCII +PASS: gdb.base/charset.exp: check value of parsed string literal in ASCII +PASS: gdb.base/charset.exp: try printing '\a' in ASCII +PASS: gdb.base/charset.exp: check value of '\a' in ASCII +PASS: gdb.base/charset.exp: check value of "\a" in ASCII +PASS: gdb.base/charset.exp: try printing '\b' in ASCII +PASS: gdb.base/charset.exp: check value of '\b' in ASCII +PASS: gdb.base/charset.exp: check value of "\b" in ASCII +PASS: gdb.base/charset.exp: try printing '\f' in ASCII +PASS: gdb.base/charset.exp: check value of '\f' in ASCII +PASS: gdb.base/charset.exp: check value of "\f" in ASCII +PASS: gdb.base/charset.exp: try printing '\n' in ASCII +PASS: gdb.base/charset.exp: check value of '\n' in ASCII +PASS: gdb.base/charset.exp: check value of "\n" in ASCII +PASS: gdb.base/charset.exp: try printing '\r' in ASCII +PASS: gdb.base/charset.exp: check value of '\r' in ASCII +PASS: gdb.base/charset.exp: check value of "\r" in ASCII +PASS: gdb.base/charset.exp: try printing '\t' in ASCII +PASS: gdb.base/charset.exp: check value of '\t' in ASCII +PASS: gdb.base/charset.exp: check value of "\t" in ASCII +PASS: gdb.base/charset.exp: try printing '\v' in ASCII +PASS: gdb.base/charset.exp: check value of '\v' in ASCII +PASS: gdb.base/charset.exp: check value of "\v" in ASCII +PASS: gdb.base/charset.exp: print escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ASCII +PASS: gdb.base/charset.exp: set target-charset ISO-8859-1 +PASS: gdb.base/charset.exp: print the null character in ISO-8859-1 +PASS: gdb.base/charset.exp: print string in ISO-8859-1 +PASS: gdb.base/charset.exp: parse character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed character literal in ISO-8859-1 +PASS: gdb.base/charset.exp: parse string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of parsed string literal in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\a' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\a" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\b' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\b" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\f' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\f" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\n' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\n" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\r' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\r" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\t' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\t" in ISO-8859-1 +PASS: gdb.base/charset.exp: try printing '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of '\v' in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of "\v" in ISO-8859-1 +PASS: gdb.base/charset.exp: print escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in ISO-8859-1 +PASS: gdb.base/charset.exp: set target-charset EBCDIC-US +PASS: gdb.base/charset.exp: print the null character in EBCDIC-US +PASS: gdb.base/charset.exp: print string in EBCDIC-US +PASS: gdb.base/charset.exp: parse character literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed character literal in EBCDIC-US +PASS: gdb.base/charset.exp: parse string literal in EBCDIC-US +PASS: gdb.base/charset.exp: check value of parsed string literal in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\a' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\a" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\b' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\b" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\f' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\f" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\n' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\n" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\r' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\r" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\t' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\t" in EBCDIC-US +PASS: gdb.base/charset.exp: try printing '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of '\v' in EBCDIC-US +PASS: gdb.base/charset.exp: check value of "\v" in EBCDIC-US +PASS: gdb.base/charset.exp: print escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in EBCDIC-US +PASS: gdb.base/charset.exp: set target-charset IBM1047 +PASS: gdb.base/charset.exp: print the null character in IBM1047 +PASS: gdb.base/charset.exp: print string in IBM1047 +PASS: gdb.base/charset.exp: parse character literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed character literal in IBM1047 +PASS: gdb.base/charset.exp: parse string literal in IBM1047 +PASS: gdb.base/charset.exp: check value of parsed string literal in IBM1047 +PASS: gdb.base/charset.exp: try printing '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\a' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\a" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\b' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\b" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\f' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\f" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\n' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\n" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\r' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\r" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\t' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\t" in IBM1047 +PASS: gdb.base/charset.exp: try printing '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of '\v' in IBM1047 +PASS: gdb.base/charset.exp: check value of "\v" in IBM1047 +PASS: gdb.base/charset.exp: print escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in IBM1047 +PASS: gdb.base/charset.exp: set target-wide-charset UTF-32 +PASS: gdb.base/charset.exp: print the null character in UTF-32 +PASS: gdb.base/charset.exp: print string in UTF-32 +PASS: gdb.base/charset.exp: parse character literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed character literal in UTF-32 +PASS: gdb.base/charset.exp: parse string literal in UTF-32 +PASS: gdb.base/charset.exp: check value of parsed string literal in UTF-32 +PASS: gdb.base/charset.exp: try printing '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\a' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\a" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\b' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\b" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\f' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\f" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\n' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\n" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\r' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\r" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\t' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\t" in UTF-32 +PASS: gdb.base/charset.exp: try printing '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of '\v' in UTF-32 +PASS: gdb.base/charset.exp: check value of "\v" in UTF-32 +PASS: gdb.base/charset.exp: print escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: check value of escape that doesn't exist in UTF-32 +PASS: gdb.base/charset.exp: set target-charset UTF-8 +PASS: gdb.base/charset.exp: non-representable target character +PASS: gdb.base/charset.exp: print '\x' +PASS: gdb.base/charset.exp: print '\u' +PASS: gdb.base/charset.exp: print '\9' +PASS: gdb.base/charset.exp: print "\1011" +PASS: gdb.base/charset.exp: basic wide string concatenation +PASS: gdb.base/charset.exp: narrow and wide string concatenation +PASS: gdb.base/charset.exp: wide and narrow string concatenation +PASS: gdb.base/charset.exp: wide string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty wide string +PASS: gdb.base/charset.exp: basic wide character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char16_t)" (2) +PASS: gdb.base/charset.exp: basic UTF-16 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-16 string concatenation +PASS: gdb.base/charset.exp: UTF-16 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-16 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-16 string +PASS: gdb.base/charset.exp: basic UTF-16 character +PASS: gdb.base/charset.exp: get integer valueof "sizeof (char32_t)" (4) +PASS: gdb.base/charset.exp: basic UTF-32 string concatenation +PASS: gdb.base/charset.exp: narrow and UTF-32 string concatenation +PASS: gdb.base/charset.exp: UTF-32 and narrow string concatenation +PASS: gdb.base/charset.exp: UTF-32 string concatenation with escape +PASS: gdb.base/charset.exp: concatenate three strings with empty UTF-32 string +PASS: gdb.base/charset.exp: basic UTF-32 character +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-16 +PASS: gdb.base/charset.exp: undefined concatenation of wide and UTF-32 +PASS: gdb.base/charset.exp: typedef to wchar_t +PASS: gdb.base/charset.exp: undefined concatenation of UTF-16 and UTF-32 +PASS: gdb.base/charset.exp: set up for python printing of utf-16 string +PASS: gdb.base/charset.exp: extract utf-16 string using python +PASS: gdb.base/charset.exp: EVAL_SKIP cleanup handling regression test +PASS: gdb.base/charset.exp: Assign String16 with prefix u +PASS: gdb.base/charset.exp: Display String String16 with x/hs +PASS: gdb.base/charset.exp: Assign String32 with prefix U +PASS: gdb.base/charset.exp: Display String String32 with x/ws +PASS: gdb.base/charset.exp: Assign String32 with prefix L +PASS: gdb.base/charset.exp: Display String String32 with x/ws +PASS: gdb.base/charset.exp: assign string to short array +PASS: gdb.base/charset.exp: assign string to int array +PASS: gdb.base/charset.exp: assign string to long array +Running ./gdb.base/checkpoint.exp ... +Running ./gdb.base/chng-syms.exp ... +PASS: gdb.base/chng-syms.exp: setting conditional breakpoint on function +PASS: gdb.base/chng-syms.exp: continue until exit at breakpoint first time through +PASS: gdb.base/chng-syms.exp: running with invalidated bpt condition after executable changes +Running ./gdb.base/code_elim.exp ... +PASS: gdb.base/code_elim.exp: symbol-file code_elim1 +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single psymtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single psymtabs: get address of main +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_static_symbol +PASS: gdb.base/code_elim.exp: single symtabs: test eliminated var my_global_func +PASS: gdb.base/code_elim.exp: single symtabs: get address of main +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order1: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order1: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order1: get address of my_global_func +PASS: gdb.base/code_elim.exp: order1: get address of main +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim2 0x200000 +PASS: gdb.base/code_elim.exp: order2: add-symbol-file code_elim1 0x100000 +PASS: gdb.base/code_elim.exp: order2: get address of my_global_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_static_symbol +PASS: gdb.base/code_elim.exp: order2: get address of my_global_func +PASS: gdb.base/code_elim.exp: order2: get address of main +Running ./gdb.base/code-expr.exp ... +PASS: gdb.base/code-expr.exp: set print sevenbit-strings +PASS: gdb.base/code-expr.exp: set print address off +PASS: gdb.base/code-expr.exp: set width 0 +PASS: gdb.base/code-expr.exp: (@code char) +PASS: gdb.base/code-expr.exp: (@code signed char) +PASS: gdb.base/code-expr.exp: (@code unsigned char) +PASS: gdb.base/code-expr.exp: (@code short) +PASS: gdb.base/code-expr.exp: (@code signed short) +PASS: gdb.base/code-expr.exp: (@code unsigned short) +PASS: gdb.base/code-expr.exp: (@code int) +PASS: gdb.base/code-expr.exp: (@code signed int) +PASS: gdb.base/code-expr.exp: (@code unsigned int) +PASS: gdb.base/code-expr.exp: (@code long) +PASS: gdb.base/code-expr.exp: (@code signed long) +PASS: gdb.base/code-expr.exp: (@code unsigned long) +PASS: gdb.base/code-expr.exp: (@code long long) +PASS: gdb.base/code-expr.exp: (@code signed long long) +PASS: gdb.base/code-expr.exp: (@code unsigned long long) +PASS: gdb.base/code-expr.exp: (@code float) +PASS: gdb.base/code-expr.exp: (@code double) +PASS: gdb.base/code-expr.exp: (@data char) +PASS: gdb.base/code-expr.exp: (@data signed char) +PASS: gdb.base/code-expr.exp: (@data unsigned char) +PASS: gdb.base/code-expr.exp: (@data short) +PASS: gdb.base/code-expr.exp: (@data signed short) +PASS: gdb.base/code-expr.exp: (@data unsigned short) +PASS: gdb.base/code-expr.exp: (@data int) +PASS: gdb.base/code-expr.exp: (@data signed int) +PASS: gdb.base/code-expr.exp: (@data unsigned int) +PASS: gdb.base/code-expr.exp: (@data long) +PASS: gdb.base/code-expr.exp: (@data signed long) +PASS: gdb.base/code-expr.exp: (@data unsigned long) +PASS: gdb.base/code-expr.exp: (@data long long) +PASS: gdb.base/code-expr.exp: (@data signed long long) +PASS: gdb.base/code-expr.exp: (@data unsigned long long) +PASS: gdb.base/code-expr.exp: (@data float) +PASS: gdb.base/code-expr.exp: (@data double) +PASS: gdb.base/code-expr.exp: (char @code) +PASS: gdb.base/code-expr.exp: (signed char @code) +PASS: gdb.base/code-expr.exp: (unsigned char @code) +PASS: gdb.base/code-expr.exp: (short @code) +PASS: gdb.base/code-expr.exp: (signed short @code) +PASS: gdb.base/code-expr.exp: (unsigned short @code) +PASS: gdb.base/code-expr.exp: (int @code) +PASS: gdb.base/code-expr.exp: (signed int @code) +PASS: gdb.base/code-expr.exp: (unsigned int @code) +PASS: gdb.base/code-expr.exp: (long @code) +PASS: gdb.base/code-expr.exp: (signed long @code) +PASS: gdb.base/code-expr.exp: (unsigned long @code) +PASS: gdb.base/code-expr.exp: (long long @code) +PASS: gdb.base/code-expr.exp: (signed long long @code) +PASS: gdb.base/code-expr.exp: (unsigned long long @code) +PASS: gdb.base/code-expr.exp: (float @code) +PASS: gdb.base/code-expr.exp: (double @code) +PASS: gdb.base/code-expr.exp: (char @data) +PASS: gdb.base/code-expr.exp: (signed char @data) +PASS: gdb.base/code-expr.exp: (unsigned char @data) +PASS: gdb.base/code-expr.exp: (short @data) +PASS: gdb.base/code-expr.exp: (signed short @data) +PASS: gdb.base/code-expr.exp: (unsigned short @data) +PASS: gdb.base/code-expr.exp: (int @data) +PASS: gdb.base/code-expr.exp: (signed int @data) +PASS: gdb.base/code-expr.exp: (unsigned int @data) +PASS: gdb.base/code-expr.exp: (long @data) +PASS: gdb.base/code-expr.exp: (signed long @data) +PASS: gdb.base/code-expr.exp: (unsigned long @data) +PASS: gdb.base/code-expr.exp: (long long @data) +PASS: gdb.base/code-expr.exp: (signed long long @data) +PASS: gdb.base/code-expr.exp: (unsigned long long @data) +PASS: gdb.base/code-expr.exp: (float @data) +PASS: gdb.base/code-expr.exp: (double @data) +PASS: gdb.base/code-expr.exp: (@code enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @code) +PASS: gdb.base/code-expr.exp: (@data enum misordered) +PASS: gdb.base/code-expr.exp: (enum misordered @data) +PASS: gdb.base/code-expr.exp: (@code int *) +PASS: gdb.base/code-expr.exp: (int @code *) +PASS: gdb.base/code-expr.exp: (int * @code) +PASS: gdb.base/code-expr.exp: (@code int * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code) +PASS: gdb.base/code-expr.exp: (@code int **) +PASS: gdb.base/code-expr.exp: (int @code **) +PASS: gdb.base/code-expr.exp: (int ** @code) +PASS: gdb.base/code-expr.exp: (@code int * @code *) +PASS: gdb.base/code-expr.exp: (int @code * @code *) +PASS: gdb.base/code-expr.exp: (@code int * @code * @code) +PASS: gdb.base/code-expr.exp: (int @code * @code * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct) +PASS: gdb.base/code-expr.exp: (@code union t_union) +PASS: gdb.base/code-expr.exp: (struct t_struct @code) +PASS: gdb.base/code-expr.exp: (union t_union @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct *) +PASS: gdb.base/code-expr.exp: (@code union t_union *) +PASS: gdb.base/code-expr.exp: (struct t_struct @code *) +PASS: gdb.base/code-expr.exp: (union t_union @code *) +PASS: gdb.base/code-expr.exp: (struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (union t_union * @code) +PASS: gdb.base/code-expr.exp: (@code struct t_struct * @code) +PASS: gdb.base/code-expr.exp: (@code union t_union * @code) +PASS: gdb.base/code-expr.exp: (struct t_struct @code * @code) +PASS: gdb.base/code-expr.exp: (union t_union @code * @code) +Running ./gdb.base/commands.exp ... +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_if_test +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #1 +PASS: gdb.base/commands.exp: gdbvar_simple_if_test #2 +PASS: gdb.base/commands.exp: set foo in gdbvar_simple_while_test +PASS: gdb.base/commands.exp: gdbvar_simple_while_test #1 +PASS: gdb.base/commands.exp: set foo in gdbvar complex_if_while_test +PASS: gdb.base/commands.exp: gdbvar_complex_if_while_test #1 +PASS: gdb.base/commands.exp: set foo in user_defined_command_test +PASS: gdb.base/commands.exp: define mycommand in user_defined_command_test +PASS: gdb.base/commands.exp: enter commands in user_defined_command_test +PASS: gdb.base/commands.exp: execute user defined command in user_defined_command_test +PASS: gdb.base/commands.exp: display user command in user_defined_command_test +PASS: gdb.base/commands.exp: tried to deprecate non-existing command +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /1/ +PASS: gdb.base/commands.exp: p deprecated warning, with replacement +PASS: gdb.base/commands.exp: Deprecated warning goes away /1/ +PASS: gdb.base/commands.exp: maintenance deprecate p "new_p" /2/ +PASS: gdb.base/commands.exp: maintenance deprecate print "new_print" +PASS: gdb.base/commands.exp: both alias and command are deprecated +PASS: gdb.base/commands.exp: Deprecated warning goes away /2/ +PASS: gdb.base/commands.exp: deprecate long command /1/ +PASS: gdb.base/commands.exp: long command deprecated /1/ +PASS: gdb.base/commands.exp: deprecate long command /2/ +PASS: gdb.base/commands.exp: long command deprecated with no alternative /2/ +PASS: gdb.base/commands.exp: deprecate with no arguments +PASS: gdb.base/commands.exp: stray_arg0_test #1 +PASS: gdb.base/commands.exp: stray_arg0_test #2 +PASS: gdb.base/commands.exp: stray_arg0_test #3 +PASS: gdb.base/commands.exp: stray_arg0_test #4 +PASS: gdb.base/commands.exp: source file with indented comment +PASS: gdb.base/commands.exp: recursive source test +PASS: gdb.base/commands.exp: set $tem in if_commands_test +PASS: gdb.base/commands.exp: if $tem == 2 - if_commands_test 1 +PASS: gdb.base/commands.exp: break main - if_commands_test 1 +PASS: gdb.base/commands.exp: else - if_commands_test 1 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 1 +PASS: gdb.base/commands.exp: commands - if_commands_test 1 +PASS: gdb.base/commands.exp: silent - if_commands_test 1 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 1 +PASS: gdb.base/commands.exp: continue - if_commands_test 1 +PASS: gdb.base/commands.exp: first end - if_commands_test 1 +PASS: gdb.base/commands.exp: second end - if_commands_test 1 +PASS: gdb.base/commands.exp: if $tem == 1 - if_commands_test 2 +PASS: gdb.base/commands.exp: break main - if_commands_test 2 +PASS: gdb.base/commands.exp: else - if_commands_test 2 +PASS: gdb.base/commands.exp: break factorial - if_commands_test 2 +PASS: gdb.base/commands.exp: commands - if_commands_test 2 +PASS: gdb.base/commands.exp: silent - if_commands_test 2 +PASS: gdb.base/commands.exp: set $tem = 3 - if_commands_test 2 +PASS: gdb.base/commands.exp: continue - if_commands_test 2 +PASS: gdb.base/commands.exp: first end - if_commands_test 2 +PASS: gdb.base/commands.exp: second end - if_commands_test 2 +PASS: gdb.base/commands.exp: hook-stop 1 +PASS: gdb.base/commands.exp: hook-stop 1a +PASS: gdb.base/commands.exp: hook-stop 1b +PASS: gdb.base/commands.exp: main commands 1 +PASS: gdb.base/commands.exp: main commands 1a +PASS: gdb.base/commands.exp: main commands 1b +PASS: gdb.base/commands.exp: main commands 1c +PASS: gdb.base/commands.exp: main commands 2 +PASS: gdb.base/commands.exp: main commands 2a +PASS: gdb.base/commands.exp: main commands 2b +PASS: gdb.base/commands.exp: main commands 2c +PASS: gdb.base/commands.exp: cmd1 error +PASS: gdb.base/commands.exp: no cmd2 +PASS: gdb.base/commands.exp: define one +PASS: gdb.base/commands.exp: define hook-one +PASS: gdb.base/commands.exp: define one in redefine_hook_test +PASS: gdb.base/commands.exp: enter commands for one redefinition in redefine_hook_test +PASS: gdb.base/commands.exp: execute one command in redefine_hook_test +PASS: gdb.base/commands.exp: define backtrace +PASS: gdb.base/commands.exp: expect response to define backtrace +PASS: gdb.base/commands.exp: enter commands in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute backtrace command in redefine_backtrace_test +PASS: gdb.base/commands.exp: execute bt command in redefine_backtrace_test +Running ./gdb.base/completion.exp ... +PASS: gdb.base/completion.exp: complete 'hfgfh' +PASS: gdb.base/completion.exp: complete 'show output' +PASS: gdb.base/completion.exp: complete 'show output-' +PASS: gdb.base/completion.exp: complete 'p' +PASS: gdb.base/completion.exp: complete 'p ' +PASS: gdb.base/completion.exp: complete 'info t foo' +PASS: gdb.base/completion.exp: complete 'info t' +PASS: gdb.base/completion.exp: complete 'info t ' +PASS: gdb.base/completion.exp: complete 'info asdfgh' +PASS: gdb.base/completion.exp: complete 'info asdfgh ' +PASS: gdb.base/completion.exp: complete 'info' +PASS: gdb.base/completion.exp: complete 'info ' +PASS: gdb.base/completion.exp: complete (2) 'info ' +PASS: gdb.base/completion.exp: complete 'help info wat' +PASS: gdb.base/completion.exp: complete 'p "break1' +XFAIL: gdb.base/completion.exp: complete 'p "break1.' +PASS: gdb.base/completion.exp: complete 'p 'arg' +PASS: gdb.base/completion.exp: complete (2) 'p 'arg' +PASS: gdb.base/completion.exp: complete 'handle signal' +PASS: gdb.base/completion.exp: complete 'handle keyword' +PASS: gdb.base/completion.exp: complete help aliases +PASS: gdb.base/completion.exp: complete 'p no_var_named_this-arg' +PASS: gdb.base/completion.exp: complete (2) 'p no_var_named_this-arg' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete (2) 'p no_var_named_this-' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p values[0].a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p values[0] . a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: complete 'p &values[0] -> a' +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: completion of field in anonymous union +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: ptype completion of field in anonymous union +ERROR: internal buffer is full. +UNRESOLVED: gdb.base/completion.exp: whatis completion of field in anonymous union +PASS: gdb.base/completion.exp: cd to ${srcdir} +PASS: gdb.base/completion.exp: directory completion +PASS: gdb.base/completion.exp: directory completion 2 +PASS: gdb.base/completion.exp: Glob remaining of directory test +PASS: gdb.base/completion.exp: complete-command 'file ./gdb.base/compl' +PASS: gdb.base/completion.exp: complete 'file ./gdb.base/complet' +PASS: gdb.base/completion.exp: complete 'info func marke' +PASS: gdb.base/completion.exp: complete 'set follow-fork-mode' +PASS: gdb.base/completion.exp: field completion with invalid field +PASS: gdb.base/completion.exp: test non-deprecated completion +PASS: gdb.base/completion.exp: test deprecated completion +PASS: gdb.base/completion.exp: complete ptype struct some_ +PASS: gdb.base/completion.exp: complete ptype enum some_ +PASS: gdb.base/completion.exp: complete ptype union some_ +PASS: gdb.base/completion.exp: complete set gnutarget aut +PASS: gdb.base/completion.exp: complete set cp-abi aut +Running ./gdb.base/complex.exp ... +PASS: gdb.base/complex.exp: print complex packed value in C +PASS: gdb.base/complex.exp: print complex value in C +Running ./gdb.base/comprdebug.exp ... +PASS: gdb.base/comprdebug.exp: file comprdebug0.o +Running ./gdb.base/condbreak.exp ... +PASS: gdb.base/condbreak.exp: breakpoint function +PASS: gdb.base/condbreak.exp: break marker1 if 1==1 +PASS: gdb.base/condbreak.exp: delete 2 +PASS: gdb.base/condbreak.exp: break break.c:92 if 1==1 +PASS: gdb.base/condbreak.exp: delete 3 +PASS: gdb.base/condbreak.exp: break marker1 if (1==1) +PASS: gdb.base/condbreak.exp: break break.c:92 if (1==1) +PASS: gdb.base/condbreak.exp: break marker2 if (a==43) +PASS: gdb.base/condbreak.exp: break marker3 if (multi_line_if_conditional(1,1,1)==0) +PASS: gdb.base/condbreak.exp: break marker4 +PASS: gdb.base/condbreak.exp: breakpoint info +PASS: gdb.base/condbreak.exp: rerun to main +PASS: gdb.base/condbreak.exp: run until breakpoint set at a line number +PASS: gdb.base/condbreak.exp: run until breakpoint at marker1 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker2 +PASS: gdb.base/condbreak.exp: break main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) thread 999 +PASS: gdb.base/condbreak.exp: break *main thread 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) task 999 +PASS: gdb.base/condbreak.exp: break *main task 999 if (1==1) +PASS: gdb.base/condbreak.exp: break *main if (1==1) t 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) th 999 +PASS: gdb.base/condbreak.exp: break *main if (1==1) ta 999 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker3 +PASS: gdb.base/condbreak.exp: run until breakpoint at marker4 +PASS: gdb.base/condbreak.exp: complete cond 1 +PASS: gdb.base/condbreak.exp: set variable $var = 1 +PASS: gdb.base/condbreak.exp: complete cond $v +PASS: gdb.base/condbreak.exp: complete cond 1 values[0].a +Running ./gdb.base/cond-eval-mode.exp ... +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation host +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation auto +PASS: gdb.base/cond-eval-mode.exp: set breakpoint condition-evaluation target +Running ./gdb.base/cond-expr.exp ... +PASS: gdb.base/cond-expr.exp: print value of cond expr (const true) +PASS: gdb.base/cond-expr.exp: print value of cond expr (const false) +PASS: gdb.base/cond-expr.exp: set variable x=14 +PASS: gdb.base/cond-expr.exp: set variable y=2 +PASS: gdb.base/cond-expr.exp: set variable z=3 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var true) +PASS: gdb.base/cond-expr.exp: set variable x=0 +PASS: gdb.base/cond-expr.exp: print value of cond expr (var false) +PASS: gdb.base/cond-expr.exp: print whatis of cond expr +Running ./gdb.base/consecutive.exp ... +PASS: gdb.base/consecutive.exp: continue to breakpoint in foo +PASS: gdb.base/consecutive.exp: get breakpoint address for foo +PASS: gdb.base/consecutive.exp: set bp, 2nd instr +PASS: gdb.base/consecutive.exp: stopped at bp, 2nd instr +Running ./gdb.base/constvars.exp ... +PASS: gdb.base/constvars.exp: break marker1 +PASS: gdb.base/constvars.exp: continue to marker1 +PASS: gdb.base/constvars.exp: up from marker1 +PASS: gdb.base/constvars.exp: ptype qux1 +PASS: gdb.base/constvars.exp: print lave +PASS: gdb.base/constvars.exp: ptype lave +PASS: gdb.base/constvars.exp: print lavish +PASS: gdb.base/constvars.exp: ptype lavish +PASS: gdb.base/constvars.exp: print lax +PASS: gdb.base/constvars.exp: ptype lax +PASS: gdb.base/constvars.exp: print lecherous +PASS: gdb.base/constvars.exp: ptype lecherous +PASS: gdb.base/constvars.exp: print lechery +PASS: gdb.base/constvars.exp: ptype lechery +PASS: gdb.base/constvars.exp: print lectern +PASS: gdb.base/constvars.exp: ptype lectern +PASS: gdb.base/constvars.exp: print leeway +PASS: gdb.base/constvars.exp: ptype leeway +PASS: gdb.base/constvars.exp: print legacy +PASS: gdb.base/constvars.exp: ptype legacy +PASS: gdb.base/constvars.exp: print laconic +PASS: gdb.base/constvars.exp: ptype laconic +PASS: gdb.base/constvars.exp: print laggard +PASS: gdb.base/constvars.exp: ptype laggard +PASS: gdb.base/constvars.exp: print lagoon +PASS: gdb.base/constvars.exp: ptype lagoon +PASS: gdb.base/constvars.exp: print laity +PASS: gdb.base/constvars.exp: ptype laity +PASS: gdb.base/constvars.exp: print lambent +PASS: gdb.base/constvars.exp: ptype lambent +PASS: gdb.base/constvars.exp: print laminated +PASS: gdb.base/constvars.exp: ptype laminated +PASS: gdb.base/constvars.exp: print lampoon +PASS: gdb.base/constvars.exp: ptype lampoon +PASS: gdb.base/constvars.exp: print languid +PASS: gdb.base/constvars.exp: ptype languid +PASS: gdb.base/constvars.exp: print *legend +PASS: gdb.base/constvars.exp: ptype legend +PASS: gdb.base/constvars.exp: print *legerdemain +PASS: gdb.base/constvars.exp: ptype legerdemain +PASS: gdb.base/constvars.exp: print *leniency +PASS: gdb.base/constvars.exp: ptype leniency +PASS: gdb.base/constvars.exp: print *leonine +PASS: gdb.base/constvars.exp: ptype leonine +PASS: gdb.base/constvars.exp: print *lesion +PASS: gdb.base/constvars.exp: ptype lesion +PASS: gdb.base/constvars.exp: print *lethal +PASS: gdb.base/constvars.exp: ptype lethal +PASS: gdb.base/constvars.exp: print *lethargic +PASS: gdb.base/constvars.exp: ptype lethargic +PASS: gdb.base/constvars.exp: print *levity +PASS: gdb.base/constvars.exp: ptype levity +PASS: gdb.base/constvars.exp: print *lewd +PASS: gdb.base/constvars.exp: ptype lewd +PASS: gdb.base/constvars.exp: print *lexicographer +PASS: gdb.base/constvars.exp: ptype lexicographer +PASS: gdb.base/constvars.exp: print *lexicon +PASS: gdb.base/constvars.exp: ptype lexicon +PASS: gdb.base/constvars.exp: print *liaison +PASS: gdb.base/constvars.exp: ptype liaison +PASS: gdb.base/constvars.exp: print *libation +PASS: gdb.base/constvars.exp: ptype libation +PASS: gdb.base/constvars.exp: print *libelous +PASS: gdb.base/constvars.exp: ptype libelous +PASS: gdb.base/constvars.exp: print *libertine +PASS: gdb.base/constvars.exp: ptype libertine +PASS: gdb.base/constvars.exp: print *libidinous +PASS: gdb.base/constvars.exp: ptype libidinous +PASS: gdb.base/constvars.exp: print *languish +PASS: gdb.base/constvars.exp: ptype languish +PASS: gdb.base/constvars.exp: print *languor +PASS: gdb.base/constvars.exp: ptype languor +PASS: gdb.base/constvars.exp: print *lank +PASS: gdb.base/constvars.exp: ptype lank +PASS: gdb.base/constvars.exp: print *lapidary +PASS: gdb.base/constvars.exp: ptype lapidary +PASS: gdb.base/constvars.exp: print *larceny +PASS: gdb.base/constvars.exp: ptype larceny +PASS: gdb.base/constvars.exp: print *largess +PASS: gdb.base/constvars.exp: ptype largess +PASS: gdb.base/constvars.exp: print *lascivious +PASS: gdb.base/constvars.exp: ptype lascivious +PASS: gdb.base/constvars.exp: print *lassitude +PASS: gdb.base/constvars.exp: ptype lassitude +PASS: gdb.base/constvars.exp: print *lamprey +PASS: gdb.base/constvars.exp: ptype lamprey +PASS: gdb.base/constvars.exp: print *lariat +PASS: gdb.base/constvars.exp: ptype lariat +PASS: gdb.base/constvars.exp: print *laudanum +PASS: gdb.base/constvars.exp: ptype laudanum +PASS: gdb.base/constvars.exp: print *lecithin +PASS: gdb.base/constvars.exp: ptype lecithin +PASS: gdb.base/constvars.exp: print *leviathan +PASS: gdb.base/constvars.exp: ptype leviathan +PASS: gdb.base/constvars.exp: print *libretto +PASS: gdb.base/constvars.exp: ptype libretto +PASS: gdb.base/constvars.exp: print *lissome +PASS: gdb.base/constvars.exp: ptype lissome +PASS: gdb.base/constvars.exp: print *locust +PASS: gdb.base/constvars.exp: ptype locust +PASS: gdb.base/constvars.exp: ptype logical +PASS: gdb.base/constvars.exp: ptype lugged +PASS: gdb.base/constvars.exp: ptype luck +PASS: gdb.base/constvars.exp: ptype lunar +PASS: gdb.base/constvars.exp: ptype lumen +PASS: gdb.base/constvars.exp: ptype lurk +PASS: gdb.base/constvars.exp: ptype lush +PASS: gdb.base/constvars.exp: ptype lynx +PASS: gdb.base/constvars.exp: ptype crass +PASS: gdb.base/constvars.exp: ptype crisp +Running ./gdb.base/corefile.exp ... +Running ./gdb.base/ctxobj.exp ... +PASS: gdb.base/ctxobj.exp: break in get_version functions +PASS: gdb.base/ctxobj.exp: continue to get_version_1 +PASS: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from partial symtab +PASS: gdb.base/ctxobj.exp: print libctxobj1's this_version_num from symtab +PASS: gdb.base/ctxobj.exp: continue to get_version_2 +PASS: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from partial symtab +PASS: gdb.base/ctxobj.exp: print libctxobj2's this_version_num from symtab +Running ./gdb.base/cursal.exp ... +PASS: gdb.base/cursal.exp: set listsize 1 +PASS: gdb.base/cursal.exp: list before run +PASS: gdb.base/cursal.exp: list in main +PASS: gdb.base/cursal.exp: list in func2 +PASS: gdb.base/cursal.exp: backtrace +PASS: gdb.base/cursal.exp: list after backtrace +PASS: gdb.base/cursal.exp: set listsize 3 +PASS: gdb.base/cursal.exp: list size 3 +Running ./gdb.base/cvexpr.exp ... +PASS: gdb.base/cvexpr.exp: set print sevenbit-strings +PASS: gdb.base/cvexpr.exp: set print address off +PASS: gdb.base/cvexpr.exp: set width 0 +PASS: gdb.base/cvexpr.exp: (const char) +PASS: gdb.base/cvexpr.exp: (const signed char) +PASS: gdb.base/cvexpr.exp: (const unsigned char) +PASS: gdb.base/cvexpr.exp: (const short) +PASS: gdb.base/cvexpr.exp: (const signed short) +PASS: gdb.base/cvexpr.exp: (const unsigned short) +PASS: gdb.base/cvexpr.exp: (const int) +PASS: gdb.base/cvexpr.exp: (const signed int) +PASS: gdb.base/cvexpr.exp: (const unsigned int) +PASS: gdb.base/cvexpr.exp: (const long) +PASS: gdb.base/cvexpr.exp: (const signed long) +PASS: gdb.base/cvexpr.exp: (const unsigned long) +PASS: gdb.base/cvexpr.exp: (const long long) +PASS: gdb.base/cvexpr.exp: (const signed long long) +PASS: gdb.base/cvexpr.exp: (const unsigned long long) +PASS: gdb.base/cvexpr.exp: (const float) +PASS: gdb.base/cvexpr.exp: (const double) +PASS: gdb.base/cvexpr.exp: (volatile char) +PASS: gdb.base/cvexpr.exp: (volatile signed char) +PASS: gdb.base/cvexpr.exp: (volatile unsigned char) +PASS: gdb.base/cvexpr.exp: (volatile short) +PASS: gdb.base/cvexpr.exp: (volatile signed short) +PASS: gdb.base/cvexpr.exp: (volatile unsigned short) +PASS: gdb.base/cvexpr.exp: (volatile int) +PASS: gdb.base/cvexpr.exp: (volatile signed int) +PASS: gdb.base/cvexpr.exp: (volatile unsigned int) +PASS: gdb.base/cvexpr.exp: (volatile long) +PASS: gdb.base/cvexpr.exp: (volatile signed long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long) +PASS: gdb.base/cvexpr.exp: (volatile long long) +PASS: gdb.base/cvexpr.exp: (volatile signed long long) +PASS: gdb.base/cvexpr.exp: (volatile unsigned long long) +PASS: gdb.base/cvexpr.exp: (volatile float) +PASS: gdb.base/cvexpr.exp: (volatile double) +PASS: gdb.base/cvexpr.exp: (const volatile int) +PASS: gdb.base/cvexpr.exp: (volatile const int) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const) +PASS: gdb.base/cvexpr.exp: (int const volatile) +PASS: gdb.base/cvexpr.exp: (int volatile const) +PASS: gdb.base/cvexpr.exp: (const volatile int *) +PASS: gdb.base/cvexpr.exp: (volatile const int *) +PASS: gdb.base/cvexpr.exp: (const int volatile) +PASS: gdb.base/cvexpr.exp: (volatile int const *) +PASS: gdb.base/cvexpr.exp: (int const volatile *) +PASS: gdb.base/cvexpr.exp: (int volatile const *) +PASS: gdb.base/cvexpr.exp: (int * const volatile) +PASS: gdb.base/cvexpr.exp: (int * volatile const) +PASS: gdb.base/cvexpr.exp: (char const) +PASS: gdb.base/cvexpr.exp: (signed char const) +PASS: gdb.base/cvexpr.exp: (unsigned char const) +PASS: gdb.base/cvexpr.exp: (short const) +PASS: gdb.base/cvexpr.exp: (signed short const) +PASS: gdb.base/cvexpr.exp: (unsigned short const) +PASS: gdb.base/cvexpr.exp: (int const) +PASS: gdb.base/cvexpr.exp: (signed int const) +PASS: gdb.base/cvexpr.exp: (unsigned int const) +PASS: gdb.base/cvexpr.exp: (long const) +PASS: gdb.base/cvexpr.exp: (signed long const) +PASS: gdb.base/cvexpr.exp: (unsigned long const) +PASS: gdb.base/cvexpr.exp: (long long const) +PASS: gdb.base/cvexpr.exp: (signed long long const) +PASS: gdb.base/cvexpr.exp: (unsigned long long const) +PASS: gdb.base/cvexpr.exp: (float const) +PASS: gdb.base/cvexpr.exp: (double const) +PASS: gdb.base/cvexpr.exp: (char volatile) +PASS: gdb.base/cvexpr.exp: (signed char volatile) +PASS: gdb.base/cvexpr.exp: (unsigned char volatile) +PASS: gdb.base/cvexpr.exp: (short volatile) +PASS: gdb.base/cvexpr.exp: (signed short volatile) +PASS: gdb.base/cvexpr.exp: (unsigned short volatile) +PASS: gdb.base/cvexpr.exp: (int volatile) +PASS: gdb.base/cvexpr.exp: (signed int volatile) +PASS: gdb.base/cvexpr.exp: (unsigned int volatile) +PASS: gdb.base/cvexpr.exp: (long volatile) +PASS: gdb.base/cvexpr.exp: (signed long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long volatile) +PASS: gdb.base/cvexpr.exp: (long long volatile) +PASS: gdb.base/cvexpr.exp: (signed long long volatile) +PASS: gdb.base/cvexpr.exp: (unsigned long long volatile) +PASS: gdb.base/cvexpr.exp: (float volatile) +PASS: gdb.base/cvexpr.exp: (double volatile) +PASS: gdb.base/cvexpr.exp: (const enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered const) +PASS: gdb.base/cvexpr.exp: (volatile enum misordered) +PASS: gdb.base/cvexpr.exp: (enum misordered volatile) +PASS: gdb.base/cvexpr.exp: (const int *) +PASS: gdb.base/cvexpr.exp: (int const *) +PASS: gdb.base/cvexpr.exp: (int * const) +PASS: gdb.base/cvexpr.exp: (const int * const) +PASS: gdb.base/cvexpr.exp: (int const * const) +PASS: gdb.base/cvexpr.exp: (const int **) +PASS: gdb.base/cvexpr.exp: (int const **) +PASS: gdb.base/cvexpr.exp: (int ** const) +PASS: gdb.base/cvexpr.exp: (const int * const *) +PASS: gdb.base/cvexpr.exp: (int const * const *) +PASS: gdb.base/cvexpr.exp: (const int * const * const) +PASS: gdb.base/cvexpr.exp: (int const * const * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct) +PASS: gdb.base/cvexpr.exp: (const union t_union) +PASS: gdb.base/cvexpr.exp: (struct t_struct const) +PASS: gdb.base/cvexpr.exp: (union t_union const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct *) +PASS: gdb.base/cvexpr.exp: (const union t_union *) +PASS: gdb.base/cvexpr.exp: (struct t_struct const *) +PASS: gdb.base/cvexpr.exp: (union t_union const *) +PASS: gdb.base/cvexpr.exp: (struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (union t_union * const) +PASS: gdb.base/cvexpr.exp: (const struct t_struct * const) +PASS: gdb.base/cvexpr.exp: (const union t_union * const) +PASS: gdb.base/cvexpr.exp: (struct t_struct const * const) +PASS: gdb.base/cvexpr.exp: (union t_union const * const) +Running ./gdb.base/dbx.exp ... +PASS: gdb.base/dbx.exp: stop in main +PASS: gdb.base/dbx.exp: status +PASS: gdb.base/dbx.exp: stop at average.c:43 +PASS: gdb.base/dbx.exp: stop in average.c:43 +PASS: gdb.base/dbx.exp: stop at main +PASS: gdb.base/dbx.exp: running to main +PASS: gdb.base/dbx.exp: assign first +PASS: gdb.base/dbx.exp: print first +PASS: gdb.base/dbx.exp: whereis my_list +PASS: gdb.base/dbx.exp: file average.c:1 +PASS: gdb.base/dbx.exp: cont 1 +PASS: gdb.base/dbx.exp: step +XFAIL: gdb.base/dbx.exp: func sum +PASS: gdb.base/dbx.exp: stop in sum +PASS: gdb.base/dbx.exp: cont 2 +XFAIL: gdb.base/dbx.exp: func print_average +Running ./gdb.base/debug-expr.exp ... +PASS: gdb.base/debug-expr.exp: set variable array[0] = 0 +PASS: gdb.base/debug-expr.exp: set variable array[1] = 1 +PASS: gdb.base/debug-expr.exp: set variable array[2] = 2 +PASS: gdb.base/debug-expr.exp: set variable array[3] = 3 +PASS: gdb.base/debug-expr.exp: set debug expression 1 +PASS: gdb.base/debug-expr.exp: print /x {char[4]} array +Running ./gdb.base/default.exp ... +PASS: gdb.base/default.exp: add-symbol-file +PASS: gdb.base/default.exp: append +PASS: gdb.base/default.exp: append binary +PASS: gdb.base/default.exp: append memory +PASS: gdb.base/default.exp: append value +PASS: gdb.base/default.exp: append binary memory +PASS: gdb.base/default.exp: append binary value +WARNING: Skipping backtrace and break tests because of GDB stub. +PASS: gdb.base/default.exp: continue +PASS: gdb.base/default.exp: continue "c" abbreviation +PASS: gdb.base/default.exp: call +PASS: gdb.base/default.exp: catch +PASS: gdb.base/default.exp: cd +PASS: gdb.base/default.exp: clear +PASS: gdb.base/default.exp: commands +PASS: gdb.base/default.exp: condition +PASS: gdb.base/default.exp: core-file +PASS: gdb.base/default.exp: delete "d" abbreviation +PASS: gdb.base/default.exp: delete +PASS: gdb.base/default.exp: define +PASS: gdb.base/default.exp: delete breakpoints +PASS: gdb.base/default.exp: delete display prompt +PASS: gdb.base/default.exp: detach +PASS: gdb.base/default.exp: directory prompt +PASS: gdb.base/default.exp: disable "dis" abbreviation +PASS: gdb.base/default.exp: disable "disa" abbreviation +PASS: gdb.base/default.exp: disable +PASS: gdb.base/default.exp: disable breakpoints +PASS: gdb.base/default.exp: disable display +PASS: gdb.base/default.exp: disassemble +PASS: gdb.base/default.exp: display +PASS: gdb.base/default.exp: do +PASS: gdb.base/default.exp: document +PASS: gdb.base/default.exp: down +PASS: gdb.base/default.exp: down-silently +PASS: gdb.base/default.exp: dump +PASS: gdb.base/default.exp: dump binary +PASS: gdb.base/default.exp: dump ihex +PASS: gdb.base/default.exp: dump memory +PASS: gdb.base/default.exp: dump srec +PASS: gdb.base/default.exp: dump tekhex +PASS: gdb.base/default.exp: dump value +PASS: gdb.base/default.exp: dump binary memory +PASS: gdb.base/default.exp: dump binary value +PASS: gdb.base/default.exp: dump ihex memory +PASS: gdb.base/default.exp: dump ihex value +PASS: gdb.base/default.exp: dump srec memory +PASS: gdb.base/default.exp: dump srec value +PASS: gdb.base/default.exp: dump tekhex memory +PASS: gdb.base/default.exp: dump tekhex value +PASS: gdb.base/default.exp: echo +PASS: gdb.base/default.exp: enable breakpoints delete +PASS: gdb.base/default.exp: enable breakpoints once +PASS: gdb.base/default.exp: enable breakpoints +PASS: gdb.base/default.exp: enable delete +PASS: gdb.base/default.exp: enable display +PASS: gdb.base/default.exp: enable once +PASS: gdb.base/default.exp: enable +PASS: gdb.base/default.exp: exec-file +PASS: gdb.base/default.exp: frame "f" abbreviation +PASS: gdb.base/default.exp: frame +PASS: gdb.base/default.exp: fg +PASS: gdb.base/default.exp: file +PASS: gdb.base/default.exp: finish +PASS: gdb.base/default.exp: forward-search +PASS: gdb.base/default.exp: gcore +PASS: gdb.base/default.exp: generate-core-file +PASS: gdb.base/default.exp: help "h" abbreviation +PASS: gdb.base/default.exp: help +PASS: gdb.base/default.exp: handle +PASS: gdb.base/default.exp: info "i" abbreviation +PASS: gdb.base/default.exp: info +PASS: gdb.base/default.exp: ignore +PASS: gdb.base/default.exp: info address +PASS: gdb.base/default.exp: info all-registers +PASS: gdb.base/default.exp: info args +PASS: gdb.base/default.exp: info bogus-gdb-command +PASS: gdb.base/default.exp: info breakpoints +PASS: gdb.base/default.exp: info copying +PASS: gdb.base/default.exp: info display +PASS: gdb.base/default.exp: info frame "f" abbreviation +PASS: gdb.base/default.exp: info frame +PASS: gdb.base/default.exp: info files +PASS: gdb.base/default.exp: info float +PASS: gdb.base/default.exp: info functions +PASS: gdb.base/default.exp: info locals +PASS: gdb.base/default.exp: info program +PASS: gdb.base/default.exp: info registers +PASS: gdb.base/default.exp: info stack "s" abbreviation +PASS: gdb.base/default.exp: info stack +PASS: gdb.base/default.exp: info set +PASS: gdb.base/default.exp: info symbol +PASS: gdb.base/default.exp: info source +PASS: gdb.base/default.exp: info sources +PASS: gdb.base/default.exp: info target +PASS: gdb.base/default.exp: info terminal +PASS: gdb.base/default.exp: info threads +PASS: gdb.base/default.exp: info types +PASS: gdb.base/default.exp: info variables +PASS: gdb.base/default.exp: info vector +PASS: gdb.base/default.exp: info warranty +PASS: gdb.base/default.exp: info watchpoints +PASS: gdb.base/default.exp: inspect +PASS: gdb.base/default.exp: jump +PASS: gdb.base/default.exp: kill +PASS: gdb.base/default.exp: list "l" abbreviation +PASS: gdb.base/default.exp: list +PASS: gdb.base/default.exp: load +PASS: gdb.base/default.exp: next "n" abbreviation +PASS: gdb.base/default.exp: next +PASS: gdb.base/default.exp: nexti "ni" abbreviation +PASS: gdb.base/default.exp: nexti +PASS: gdb.base/default.exp: output +PASS: gdb.base/default.exp: overlay +PASS: gdb.base/default.exp: overlay on +PASS: gdb.base/default.exp: overlay manual #1 +PASS: gdb.base/default.exp: overlay auto +PASS: gdb.base/default.exp: overlay off +PASS: gdb.base/default.exp: overlay list +PASS: gdb.base/default.exp: overlay map #1 +PASS: gdb.base/default.exp: overlay unmap #1 +PASS: gdb.base/default.exp: overlay manual #2 +PASS: gdb.base/default.exp: overlay map #2 +PASS: gdb.base/default.exp: overlay unmap #2 +PASS: gdb.base/default.exp: print "p" abbreviation +PASS: gdb.base/default.exp: print +PASS: gdb.base/default.exp: printf +PASS: gdb.base/default.exp: ptype +PASS: gdb.base/default.exp: pwd +PASS: gdb.base/default.exp: rbreak +PASS: gdb.base/default.exp: restore +PASS: gdb.base/default.exp: return +PASS: gdb.base/default.exp: reverse-search +PASS: gdb.base/default.exp: step "s" abbreviation #1 +PASS: gdb.base/default.exp: step #1 +PASS: gdb.base/default.exp: search +PASS: gdb.base/default.exp: section +PASS: gdb.base/default.exp: set annotate +PASS: gdb.base/default.exp: set args +PASS: gdb.base/default.exp: set check "c" abbreviation +PASS: gdb.base/default.exp: set check "ch" abbreviation +PASS: gdb.base/default.exp: set check "check" abbreviation +PASS: gdb.base/default.exp: set check range +PASS: gdb.base/default.exp: set check type +PASS: gdb.base/default.exp: set complaints +PASS: gdb.base/default.exp: set confirm +PASS: gdb.base/default.exp: set environment +PASS: gdb.base/default.exp: set height +PASS: gdb.base/default.exp: set history expansion +PASS: gdb.base/default.exp: set history filename +PASS: gdb.base/default.exp: set history save +PASS: gdb.base/default.exp: set history size +PASS: gdb.base/default.exp: set history +PASS: gdb.base/default.exp: set language +PASS: gdb.base/default.exp: set listsize +PASS: gdb.base/default.exp: set print "p" abbreviation +PASS: gdb.base/default.exp: set print "pr" abbreviation +PASS: gdb.base/default.exp: set print +PASS: gdb.base/default.exp: set print address +PASS: gdb.base/default.exp: set print array +PASS: gdb.base/default.exp: set print asm-demangle +PASS: gdb.base/default.exp: set print demangle +PASS: gdb.base/default.exp: set print elements +PASS: gdb.base/default.exp: set print object +PASS: gdb.base/default.exp: set print pretty +PASS: gdb.base/default.exp: set print sevenbit-strings +PASS: gdb.base/default.exp: set print union +PASS: gdb.base/default.exp: set print vtbl +PASS: gdb.base/default.exp: set radix +PASS: gdb.base/default.exp: set variable +PASS: gdb.base/default.exp: set verbose +PASS: gdb.base/default.exp: set width +PASS: gdb.base/default.exp: set write +PASS: gdb.base/default.exp: set +PASS: gdb.base/default.exp: shell echo Hi dad! +PASS: gdb.base/default.exp: show annotate +PASS: gdb.base/default.exp: show args +PASS: gdb.base/default.exp: show check "c" abbreviation +PASS: gdb.base/default.exp: show check "ch" abbreviation +PASS: gdb.base/default.exp: show check "check" abbreviation +PASS: gdb.base/default.exp: show check range +PASS: gdb.base/default.exp: show check type +PASS: gdb.base/default.exp: show commands +PASS: gdb.base/default.exp: show complaints +PASS: gdb.base/default.exp: show confirm +PASS: gdb.base/default.exp: show convenience +PASS: gdb.base/default.exp: show directories +PASS: gdb.base/default.exp: show editing +PASS: gdb.base/default.exp: show height +PASS: gdb.base/default.exp: show history expansion +PASS: gdb.base/default.exp: show history filename +PASS: gdb.base/default.exp: show history save +PASS: gdb.base/default.exp: show history size +PASS: gdb.base/default.exp: show history +PASS: gdb.base/default.exp: show language +PASS: gdb.base/default.exp: show listsize +PASS: gdb.base/default.exp: show p +PASS: gdb.base/default.exp: show pr +PASS: gdb.base/default.exp: show print +PASS: gdb.base/default.exp: show paths +PASS: gdb.base/default.exp: show print address +PASS: gdb.base/default.exp: show print array +PASS: gdb.base/default.exp: show print asm-demangle +PASS: gdb.base/default.exp: show print demangle +PASS: gdb.base/default.exp: show print elements +PASS: gdb.base/default.exp: show print object +PASS: gdb.base/default.exp: show print pretty +PASS: gdb.base/default.exp: show print sevenbit-strings +PASS: gdb.base/default.exp: show print union +PASS: gdb.base/default.exp: show print vtbl +PASS: gdb.base/default.exp: show prompt +PASS: gdb.base/default.exp: show radix +PASS: gdb.base/default.exp: show user +PASS: gdb.base/default.exp: show values +PASS: gdb.base/default.exp: show verbose +PASS: gdb.base/default.exp: show version +PASS: gdb.base/default.exp: show width +PASS: gdb.base/default.exp: show write +PASS: gdb.base/default.exp: show +PASS: gdb.base/default.exp: stepi "si" abbreviation +PASS: gdb.base/default.exp: stepi +PASS: gdb.base/default.exp: signal +PASS: gdb.base/default.exp: source +PASS: gdb.base/default.exp: step "s" abbreviation #2 +PASS: gdb.base/default.exp: step #2 +PASS: gdb.base/default.exp: symbol-file +PASS: gdb.base/default.exp: target child +PASS: gdb.base/default.exp: target procfs +PASS: gdb.base/default.exp: target core +PASS: gdb.base/default.exp: target exec +PASS: gdb.base/default.exp: target remote +PASS: gdb.base/default.exp: target +PASS: gdb.base/default.exp: tbreak +PASS: gdb.base/default.exp: thread +PASS: gdb.base/default.exp: thread apply +PASS: gdb.base/default.exp: thread find +PASS: gdb.base/default.exp: thread name +PASS: gdb.base/default.exp: tty +PASS: gdb.base/default.exp: until "u" abbreviation +PASS: gdb.base/default.exp: until +PASS: gdb.base/default.exp: undisplay prompt +PASS: gdb.base/default.exp: unset environment prompt +PASS: gdb.base/default.exp: unset +PASS: gdb.base/default.exp: up-silently +PASS: gdb.base/default.exp: watch +PASS: gdb.base/default.exp: whatis +PASS: gdb.base/default.exp: where +PASS: gdb.base/default.exp: x +Running ./gdb.base/define.exp ... +PASS: gdb.base/define.exp: define user command: nextwhere +PASS: gdb.base/define.exp: use user command: nextwhere +PASS: gdb.base/define.exp: define user command: nextwh +PASS: gdb.base/define.exp: redefine user command aborted: nextwhere +PASS: gdb.base/define.exp: redefine user command: nextwhere +PASS: gdb.base/define.exp: redocumenting builtin command disallowed +PASS: gdb.base/define.exp: document user command: nextwhere +PASS: gdb.base/define.exp: re-document user command: nextwhere +PASS: gdb.base/define.exp: help user command: nextwhere +PASS: gdb.base/define.exp: set up whitespace in help string +PASS: gdb.base/define.exp: preserve whitespace in help string +PASS: gdb.base/define.exp: define user command: ifnospace +PASS: gdb.base/define.exp: test ifnospace is parsed correctly +PASS: gdb.base/define.exp: define user command: whilenospace +PASS: gdb.base/define.exp: test whilenospace is parsed correctly +PASS: gdb.base/define.exp: define user command: user-bt +PASS: gdb.base/define.exp: define hook-stop command +PASS: gdb.base/define.exp: use hook-stop command +PASS: gdb.base/define.exp: define hook undefined command aborted: bar +PASS: gdb.base/define.exp: define hook undefined command: bar +PASS: gdb.base/define.exp: define target testsuite +PASS: gdb.base/define.exp: document target testsuite +PASS: gdb.base/define.exp: help target +PASS: gdb.base/define.exp: target testsuite +PASS: gdb.base/define.exp: show user target testsuite +PASS: gdb.base/define.exp: define target hook-testsuite +PASS: gdb.base/define.exp: define target hookpost-testsuite +PASS: gdb.base/define.exp: target testsuite with hooks +PASS: gdb.base/define.exp: set gdb_prompt +PASS: gdb.base/define.exp: reset gdb_prompt +Running ./gdb.base/del.exp ... +PASS: gdb.base/del.exp: Remove all breakpoints (del) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (del) +PASS: gdb.base/del.exp: Remove last breakpoint (del) +PASS: gdb.base/del.exp: info break after removing break on main (del) +PASS: gdb.base/del.exp: Remove all breakpoints (d) +PASS: gdb.base/del.exp: info break after removing break on main +PASS: gdb.base/del.exp: breakpoint insertion (d) +PASS: gdb.base/del.exp: Remove last breakpoint (d) +PASS: gdb.base/del.exp: info break after removing break on main (d) +Running ./gdb.base/detach.exp ... +Running ./gdb.base/dfp-exprs.exp ... +PASS: gdb.base/dfp-exprs.exp: p 1.2df +PASS: gdb.base/dfp-exprs.exp: p -1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.234567df +PASS: gdb.base/dfp-exprs.exp: p -1.234567df +PASS: gdb.base/dfp-exprs.exp: p 1234567.df +PASS: gdb.base/dfp-exprs.exp: p -1234567.df +PASS: gdb.base/dfp-exprs.exp: p 1.2E1df +PASS: gdb.base/dfp-exprs.exp: p 1.2E10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10df +PASS: gdb.base/dfp-exprs.exp: p 1.2E96df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd +PASS: gdb.base/dfp-exprs.exp: p -1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456dd +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456.dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dd +PASS: gdb.base/dfp-exprs.exp: p 1.2E384dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl +PASS: gdb.base/dfp-exprs.exp: p -1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p -1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-exprs.exp: p 1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p -1234567890123456789012345678901234.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E-10dl +PASS: gdb.base/dfp-exprs.exp: p 1.2E6144dl +PASS: gdb.base/dfp-exprs.exp: p 1.4df + 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df - 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df * 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4df / 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.4dd + 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd - 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd * 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dd / 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.4dl + 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl - 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl * 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.4dl / 1.2dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.df +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.dl + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 2.1df + 2.7dd +PASS: gdb.base/dfp-exprs.exp: p 2.1dd + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.6df + 2.7dl +PASS: gdb.base/dfp-exprs.exp: p 2.6dl + 2.7df +PASS: gdb.base/dfp-exprs.exp: p 2.3dd + 2.2dl +PASS: gdb.base/dfp-exprs.exp: p 2.3dl + 2.2dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dd +PASS: gdb.base/dfp-exprs.exp: ptype 2.df + 2.dl +PASS: gdb.base/dfp-exprs.exp: ptype 2.dd + 2.dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: p 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: p 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: ptype 1.2df + 1 +PASS: gdb.base/dfp-exprs.exp: ptype 2 + 1.7dd +PASS: gdb.base/dfp-exprs.exp: ptype 3 + 2.1dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 2ll +PASS: gdb.base/dfp-exprs.exp: p 1.2df + 1.2f +PASS: gdb.base/dfp-exprs.exp: p !0.df +PASS: gdb.base/dfp-exprs.exp: p !0.dd +PASS: gdb.base/dfp-exprs.exp: p !0.dl +PASS: gdb.base/dfp-exprs.exp: p !0.5df +PASS: gdb.base/dfp-exprs.exp: p !0.5dd +PASS: gdb.base/dfp-exprs.exp: p !0.5dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2df == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd == 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dl == 1.3dd +PASS: gdb.base/dfp-exprs.exp: p +1.2df +PASS: gdb.base/dfp-exprs.exp: p +1.2dd +PASS: gdb.base/dfp-exprs.exp: p +1.2dl +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dd +PASS: gdb.base/dfp-exprs.exp: p 1.2dd < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3dl +PASS: gdb.base/dfp-exprs.exp: p 1.2dl < 1.3df +PASS: gdb.base/dfp-exprs.exp: p 1.2df > 1 +PASS: gdb.base/dfp-exprs.exp: p 1.2dl > 2 +PASS: gdb.base/dfp-exprs.exp: p 2 > 1.2dd +PASS: gdb.base/dfp-exprs.exp: p 2 > 3.1dl +PASS: gdb.base/dfp-exprs.exp: p (float) -0.1df +PASS: gdb.base/dfp-exprs.exp: p (int) 8.3dd +PASS: gdb.base/dfp-exprs.exp: p (_Decimal64) 3.1 +PASS: gdb.base/dfp-exprs.exp: p (_Decimal128) 3.7df +PASS: gdb.base/dfp-exprs.exp: p (_Decimal32) 4 +Running ./gdb.base/dfp-test.exp ... +PASS: gdb.base/dfp-test.exp: get integer valueof "sizeof (long)" (8) +PASS: gdb.base/dfp-test.exp: next after initializing d32 +PASS: gdb.base/dfp-test.exp: d32 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d32 +PASS: gdb.base/dfp-test.exp: d32 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d32 +PASS: gdb.base/dfp-test.exp: d32 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d32 +PASS: gdb.base/dfp-test.exp: d32 is NaN +PASS: gdb.base/dfp-test.exp: p d32=123.45df +PASS: gdb.base/dfp-test.exp: p d32=12345.df +PASS: gdb.base/dfp-test.exp: p d32=12345.67df +PASS: gdb.base/dfp-test.exp: p d32=1234567.df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E0df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E10df +PASS: gdb.base/dfp-test.exp: p d32=1.234567E+96df +PASS: gdb.base/dfp-test.exp: p d32=9.999999E96df +PASS: gdb.base/dfp-test.exp: p d32=1.0E-95df +PASS: gdb.base/dfp-test.exp: p d32=1.E-101df +PASS: gdb.base/dfp-test.exp: p d32=0.000001E-95df +PASS: gdb.base/dfp-test.exp: 1.2345678 is rounded to 1.234568 +PASS: gdb.base/dfp-test.exp: 1.0E-101 is rounded to 1E-101 +PASS: gdb.base/dfp-test.exp: 1.234567E+97 is Infinity +PASS: gdb.base/dfp-test.exp: 12345. is a valid number +PASS: gdb.base/dfp-test.exp: 12345 is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after initializing d64 +PASS: gdb.base/dfp-test.exp: d64 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d64 +PASS: gdb.base/dfp-test.exp: d64 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d64 +PASS: gdb.base/dfp-test.exp: d64 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d64 +PASS: gdb.base/dfp-test.exp: d64 is NaN +PASS: gdb.base/dfp-test.exp: p d64=123.45dd +PASS: gdb.base/dfp-test.exp: p d64=12345.dd +PASS: gdb.base/dfp-test.exp: p d64=12345.67dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E10dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E100dd +PASS: gdb.base/dfp-test.exp: p d64=1.234567890123456E384dd +PASS: gdb.base/dfp-test.exp: p d64=9.999999999999999E384dd +PASS: gdb.base/dfp-test.exp: p d64=1.E-383dd +PASS: gdb.base/dfp-test.exp: p d64=1.E-398dd +PASS: gdb.base/dfp-test.exp: p d64=0.000000000000001E-383dd +PASS: gdb.base/dfp-test.exp: 1.2345678901234567 is rounded to 1.234567890123457 +PASS: gdb.base/dfp-test.exp: d64=9.9999999999999999E384 is Infinity +PASS: gdb.base/dfp-test.exp: d64=1.234567890123456E385 is Infinity +PASS: gdb.base/dfp-test.exp: 12345dd is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after initializing d128 +PASS: gdb.base/dfp-test.exp: d128 is initialized to 1.2345 +PASS: gdb.base/dfp-test.exp: p d128=123.45dl +PASS: gdb.base/dfp-test.exp: p d128=12345.dl +PASS: gdb.base/dfp-test.exp: p d128=12345.67dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456789012345678901234dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E10dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E100dl +PASS: gdb.base/dfp-test.exp: p d128=1.234567890123456E1000dl +PASS: gdb.base/dfp-test.exp: p d128=9.999999999999999999999999999999999E6144dl +PASS: gdb.base/dfp-test.exp: p d128=1.E-6143dl +PASS: gdb.base/dfp-test.exp: p d128=1.E-6176dl +PASS: gdb.base/dfp-test.exp: p d128=0.000000000000000000000000000000001E-6143dl +PASS: gdb.base/dfp-test.exp: 1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234 +PASS: gdb.base/dfp-test.exp: d128=1.234567890123456E6145 is Infinity +PASS: gdb.base/dfp-test.exp: 12345dl is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E is an invalid number +PASS: gdb.base/dfp-test.exp: 1.23E45A is an invalid number +PASS: gdb.base/dfp-test.exp: next after assigning builtin infinity to d128 +PASS: gdb.base/dfp-test.exp: d128 is positive Infinity +PASS: gdb.base/dfp-test.exp: next after assigning negative builtin infinity to d128 +PASS: gdb.base/dfp-test.exp: d128 is negative Infinity +PASS: gdb.base/dfp-test.exp: next after assigning builtin NaN to d128 +PASS: gdb.base/dfp-test.exp: d128 is NaN +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_32 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_32 +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_64 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_64 +PASS: gdb.base/dfp-test.exp: continue to breakpoint: entry to arg0_128 +PASS: gdb.base/dfp-test.exp: backtrace at arg0_128 +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal32 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal64 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with correct _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Backtrace function with correct _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Correct _Decimal128 return value from called function. +PASS: gdb.base/dfp-test.exp: Call function with mixed decimal float arguments TEST. +PASS: gdb.base/dfp-test.exp: Call function with mixed decimal float arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal32 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal64 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many _Decimal128 arguments. +PASS: gdb.base/dfp-test.exp: Call function with many mixed decimal float arguments. +PASS: gdb.base/dfp-test.exp: continue to breakpoint: Setting a decimal struct +PASS: gdb.base/dfp-test.exp: print ds.dec32 +PASS: gdb.base/dfp-test.exp: print ds.dec64 +PASS: gdb.base/dfp-test.exp: print ds.dec128 +PASS: gdb.base/dfp-test.exp: print d32 + ds.dec32 +PASS: gdb.base/dfp-test.exp: print d64 + ds.dec64 +PASS: gdb.base/dfp-test.exp: print d128 + ds.dec128 +PASS: gdb.base/dfp-test.exp: ptype d64 + ds.dec32 +PASS: gdb.base/dfp-test.exp: ptype d128 + ds.dec32 +PASS: gdb.base/dfp-test.exp: ptype d128 + ds.dec64 +PASS: gdb.base/dfp-test.exp: p d32 + 1 +PASS: gdb.base/dfp-test.exp: p 2 + d64 +PASS: gdb.base/dfp-test.exp: p ds.int4 + d128 +PASS: gdb.base/dfp-test.exp: ptype d32 + 1 +PASS: gdb.base/dfp-test.exp: ptype ds.int4 + d128 +PASS: gdb.base/dfp-test.exp: p !d32 +PASS: gdb.base/dfp-test.exp: p !d64 +PASS: gdb.base/dfp-test.exp: p !d128 +PASS: gdb.base/dfp-test.exp: p +d32 +PASS: gdb.base/dfp-test.exp: p +d64 +PASS: gdb.base/dfp-test.exp: p +d128 +PASS: gdb.base/dfp-test.exp: p d64 == d128 +PASS: gdb.base/dfp-test.exp: p d128 == ds.dec32 +PASS: gdb.base/dfp-test.exp: p d128 == d32 +PASS: gdb.base/dfp-test.exp: p ds.dec32 == ds.dec64 +PASS: gdb.base/dfp-test.exp: p d32 < ds.dec32 +PASS: gdb.base/dfp-test.exp: p d64 < ds.dec64 +PASS: gdb.base/dfp-test.exp: p d128 < ds.dec128 +PASS: gdb.base/dfp-test.exp: p ds.dec32 < d32 +PASS: gdb.base/dfp-test.exp: p d64 > ds.dec64 +PASS: gdb.base/dfp-test.exp: p ds.dec128 > d128 +PASS: gdb.base/dfp-test.exp: p d32 < ds.int4 +PASS: gdb.base/dfp-test.exp: p ds.int4 > d32 +PASS: gdb.base/dfp-test.exp: p ds.dec32 < ds.int4 +PASS: gdb.base/dfp-test.exp: p ds.int4 > ds.dec64 +PASS: gdb.base/dfp-test.exp: p ds.dec128 > ds.int4 +PASS: gdb.base/dfp-test.exp: p d32 + ds.long8 +PASS: gdb.base/dfp-test.exp: p d64 + ds.float4 +PASS: gdb.base/dfp-test.exp: p ds.double8 + d128 +PASS: gdb.base/dfp-test.exp: print ds.dec32=d32 +PASS: gdb.base/dfp-test.exp: print ds.dec64=d64 +PASS: gdb.base/dfp-test.exp: print ds.dec128=d128 +PASS: gdb.base/dfp-test.exp: print ds.dec32 = -d32 +PASS: gdb.base/dfp-test.exp: print ds.dec64 = -d64 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = -d128 +PASS: gdb.base/dfp-test.exp: print ds.double8 = ds.dec64 +PASS: gdb.base/dfp-test.exp: print ds.dec64 = ds.float4 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = -ds.double8 +PASS: gdb.base/dfp-test.exp: print ds.dec128 = ds.dec32 +PASS: gdb.base/dfp-test.exp: print ds.dec32 = ds.int4 +PASS: gdb.base/dfp-test.exp: print ds.int4 = 7.3dl +Running ./gdb.base/disabled-location.exp ... +PASS: gdb.base/disabled-location.exp: setting breakpoint on function +PASS: gdb.base/disabled-location.exp: disable location +PASS: gdb.base/disabled-location.exp: step doesn't trip on disabled location +Running ./gdb.base/disasm-end-cu.exp ... +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&main" +PASS: gdb.base/disasm-end-cu.exp: get hexadecimal valueof "&dummy_3" +PASS: gdb.base/disasm-end-cu.exp: disassemble command returned some output +Running ./gdb.base/display.exp ... +PASS: gdb.base/display.exp: break do_loops +PASS: gdb.base/display.exp: get to do_loops +PASS: gdb.base/display.exp: set watch +PASS: gdb.base/display.exp: break loop end +PASS: gdb.base/display.exp: inf disp +PASS: gdb.base/display.exp: display i +PASS: gdb.base/display.exp: display j +PASS: gdb.base/display.exp: display &k +PASS: gdb.base/display.exp: display/f f +PASS: gdb.base/display.exp: display/s &sum +PASS: gdb.base/display.exp: first disp +PASS: gdb.base/display.exp: second disp +PASS: gdb.base/display.exp: catch err +PASS: gdb.base/display.exp: disab disp 1 +PASS: gdb.base/display.exp: disab disp 2 +PASS: gdb.base/display.exp: re-enab +PASS: gdb.base/display.exp: re-enab of enab +PASS: gdb.base/display.exp: undisp +PASS: gdb.base/display.exp: info disp +PASS: gdb.base/display.exp: next hit +PASS: gdb.base/display.exp: undisp all +PASS: gdb.base/display.exp: disp *p_i +PASS: gdb.base/display.exp: p p_i = 0x0 +PASS: gdb.base/display.exp: display bad address +PASS: gdb.base/display.exp: p p_i = &i +PASS: gdb.base/display.exp: display good address +PASS: gdb.base/display.exp: undisp all again +PASS: gdb.base/display.exp: disab 3 +PASS: gdb.base/display.exp: watch off +PASS: gdb.base/display.exp: finish +PASS: gdb.base/display.exp: step +PASS: gdb.base/display.exp: tbreak in do_vars +PASS: gdb.base/display.exp: cont +PASS: gdb.base/display.exp: printf +PASS: gdb.base/display.exp: printf %d +PASS: gdb.base/display.exp: printf "%d +PASS: gdb.base/display.exp: printf "%d%d",i +PASS: gdb.base/display.exp: printf "\\!\a\f\r\t\v\b\n" +PASS: gdb.base/display.exp: re-set term +PASS: gdb.base/display.exp: printf "\w" +PASS: gdb.base/display.exp: printf "%d" j +PASS: gdb.base/display.exp: printf "%p\n", 0 +PASS: gdb.base/display.exp: printf "%p\n", 1 +PASS: gdb.base/display.exp: print/z j +PASS: gdb.base/display.exp: debug test output 1 +PASS: gdb.base/display.exp: debug test output 1a +PASS: gdb.base/display.exp: debug test output 2 +PASS: gdb.base/display.exp: debug test output 2a +PASS: gdb.base/display.exp: debug test output 3 +PASS: gdb.base/display.exp: x/0 j +PASS: gdb.base/display.exp: print/0 j +PASS: gdb.base/display.exp: ignored s +PASS: gdb.base/display.exp: no i +PASS: gdb.base/display.exp: print/a &sum +PASS: gdb.base/display.exp: print/a main+4 +PASS: gdb.base/display.exp: print/a $pc +PASS: gdb.base/display.exp: print/a &&j +Running ./gdb.base/disp-step-syscall.exp ... +PASS: gdb.base/disp-step-syscall.exp: fork: delete break 1 +PASS: gdb.base/disp-step-syscall.exp: fork: break marker +PASS: gdb.base/disp-step-syscall.exp: fork: set displaced-stepping off +PASS: gdb.base/disp-step-syscall.exp: fork: break fork +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (1st time) +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (2nd time) +PASS: gdb.base/disp-step-syscall.exp: fork: display/i $pc +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: stepi fork insn +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: continue to fork (3rd time) +PASS: gdb.base/disp-step-syscall.exp: fork: break on syscall insns +PASS: gdb.base/disp-step-syscall.exp: fork: delete break fork +PASS: gdb.base/disp-step-syscall.exp: fork: continue to syscall insn fork +PASS: gdb.base/disp-step-syscall.exp: fork: set displaced-stepping on +PASS: gdb.base/disp-step-syscall.exp: fork: single step over fork +PASS: gdb.base/disp-step-syscall.exp: fork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: fork: single step over fork final pc +PASS: gdb.base/disp-step-syscall.exp: fork: delete break fork insn +PASS: gdb.base/disp-step-syscall.exp: fork: continue to marker (fork) +PASS: gdb.base/disp-step-syscall.exp: vfork: delete break 1 +PASS: gdb.base/disp-step-syscall.exp: vfork: break marker +PASS: gdb.base/disp-step-syscall.exp: vfork: set displaced-stepping off +PASS: gdb.base/disp-step-syscall.exp: vfork: break vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (1st time) +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (2nd time) +PASS: gdb.base/disp-step-syscall.exp: vfork: display/i $pc +PASS: gdb.base/disp-step-syscall.exp: vfork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: vfork: stepi vfork insn +PASS: gdb.base/disp-step-syscall.exp: vfork: get hexadecimal valueof "$pc" +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to vfork (3rd time) +PASS: gdb.base/disp-step-syscall.exp: vfork: break on syscall insns +PASS: gdb.base/disp-step-syscall.exp: vfork: delete break vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: continue to syscall insn vfork +PASS: gdb.base/disp-step-syscall.exp: vfork: set displaced-stepping on +KFAIL: gdb.base/disp-step-syscall.exp: vfork: single step over vfork (PRMS: server/13796) +Running ./gdb.base/dmsym.exp ... +PASS: gdb.base/dmsym.exp: set lang ada +PASS: gdb.base/dmsym.exp: break pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: info line pck__foo__bar__minsym +PASS: gdb.base/dmsym.exp: set lang auto +PASS: gdb.base/dmsym.exp: Run until breakpoint at BREAK +PASS: gdb.base/dmsym.exp: continue +PASS: gdb.base/dmsym.exp: print val +Running ./gdb.base/dprintf.exp ... +PASS: gdb.base/dprintf.exp: dprintf +PASS: gdb.base/dprintf.exp: dprintf foo +PASS: gdb.base/dprintf.exp: dprintf 29 +PASS: gdb.base/dprintf.exp: dprintf foo,"At foo entry\n" +PASS: gdb.base/dprintf.exp: ignore $bpnum 1 +PASS: gdb.base/dprintf.exp: dprintf 26,"arg=%d, g=%d\n", arg, g +PASS: gdb.base/dprintf.exp: dprintf info 1 +PASS: gdb.base/dprintf.exp: break 27 +PASS: gdb.base/dprintf.exp: 1st dprintf, gdb +PASS: gdb.base/dprintf.exp: 2nd dprintf, gdb +PASS: gdb.base/dprintf.exp: Set dprintf style to agent - can do +PASS: gdb.base/dprintf.exp: 1st dprintf, agent +PASS: gdb.base/dprintf.exp: 2nd dprintf, agent +PASS: gdb.base/dprintf.exp: dprintf info 2 +PASS: gdb.base/dprintf.exp: Set dprintf style to an unrecognized type +Running ./gdb.base/dprintf-next.exp ... +PASS: gdb.base/dprintf-next.exp: dprintf 24, "%d\n", x +PASS: gdb.base/dprintf-next.exp: next 1 +PASS: gdb.base/dprintf-next.exp: next 2 +Running ./gdb.base/dprintf-non-stop.exp ... +UNSUPPORTED: gdb.base/dprintf-non-stop.exp: Testing dprintf with remote/non-stop is not supported. +Running ./gdb.base/dprintf-pending.exp ... +PASS: gdb.base/dprintf-pending.exp: without format: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: without format: resolved dprintf fails to be re-set +PASS: gdb.base/dprintf-pending.exp: without symbols: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: without symbols: single pending dprintf info +PASS: gdb.base/dprintf-pending.exp: without symbols: run to resolved dprintf +PASS: gdb.base/dprintf-pending.exp: set pending dprintf +PASS: gdb.base/dprintf-pending.exp: single pending dprintf info +PASS: gdb.base/dprintf-pending.exp: run to resolved dprintf +Running ./gdb.base/dump.exp ... +PASS: gdb.base/dump.exp: inaccessible memory is reported +PASS: gdb.base/dump.exp: endianness: little +PASS: gdb.base/dump.exp: dump array as value, default +PASS: gdb.base/dump.exp: dump struct as value, default +PASS: gdb.base/dump.exp: dump array as value, binary +PASS: gdb.base/dump.exp: dump struct as value, binary +PASS: gdb.base/dump.exp: dump array as value, srec +PASS: gdb.base/dump.exp: dump struct as value, srec +FAIL: gdb.base/dump.exp: dump array as value, intel hex +FAIL: gdb.base/dump.exp: dump struct as value, intel hex +PASS: gdb.base/dump.exp: dump array as value, tekhex +PASS: gdb.base/dump.exp: dump struct as value, tekhex +PASS: gdb.base/dump.exp: capture /x &intarray[0] +PASS: gdb.base/dump.exp: capture /x &intarray[32] +PASS: gdb.base/dump.exp: capture /x &intstruct +PASS: gdb.base/dump.exp: capture /x &intstruct + 1 +PASS: gdb.base/dump.exp: capture intarray +PASS: gdb.base/dump.exp: capture intstruct +PASS: gdb.base/dump.exp: capture type of pointer &intarray +PASS: gdb.base/dump.exp: capture type of pointer &intstruct +PASS: gdb.base/dump.exp: dump array as memory, default +PASS: gdb.base/dump.exp: dump struct as memory, default +PASS: gdb.base/dump.exp: dump array as memory, binary +PASS: gdb.base/dump.exp: dump struct as memory, binary +PASS: gdb.base/dump.exp: dump array as memory, srec +PASS: gdb.base/dump.exp: dump struct as memory, srec +FAIL: gdb.base/dump.exp: dump array as memory, ihex +FAIL: gdb.base/dump.exp: dump struct as memory, ihex +PASS: gdb.base/dump.exp: dump array as memory, tekhex +PASS: gdb.base/dump.exp: dump struct as memory, tekhex +PASS: gdb.base/dump.exp: dump array as mem, srec, expressions +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, srec; file restored ok +PASS: gdb.base/dump.exp: array as value, srec; capture intarray +FAIL: gdb.base/dump.exp: array as value, srec; value restored ok +PASS: gdb.base/dump.exp: struct as value, srec; file restored ok +PASS: gdb.base/dump.exp: struct as value, srec; capture intstruct +FAIL: gdb.base/dump.exp: struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: zero all +PASS: gdb.base/dump.exp: array as memory, srec; file restored ok +PASS: gdb.base/dump.exp: array as memory, srec; capture intarray +FAIL: gdb.base/dump.exp: array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; file restored ok +PASS: gdb.base/dump.exp: struct as memory, srec; capture intstruct +FAIL: gdb.base/dump.exp: struct as memory, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array as value, ihex; file restored ok +PASS: gdb.base/dump.exp: array as value, ihex; capture intarray +FAIL: gdb.base/dump.exp: array as value, ihex; value restored ok +FAIL: gdb.base/dump.exp: struct as value, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as value, ihex; capture intstruct +FAIL: gdb.base/dump.exp: struct as value, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: array as memory, ihex; capture intarray +FAIL: gdb.base/dump.exp: array as memory, ihex; value restored ok +FAIL: gdb.base/dump.exp: struct as memory, ihex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, ihex; capture intstruct +FAIL: gdb.base/dump.exp: struct as memory, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as value, tekhex; capture intarray +FAIL: gdb.base/dump.exp: array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as value, tekhex; capture intstruct +FAIL: gdb.base/dump.exp: struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: array as memory, tekhex; capture intarray +FAIL: gdb.base/dump.exp: array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct as memory, tekhex; capture intstruct +FAIL: gdb.base/dump.exp: struct as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as value, binary; file restored ok +PASS: gdb.base/dump.exp: array as value, binary; capture intarray +PASS: gdb.base/dump.exp: array as value, binary; value restored ok +PASS: gdb.base/dump.exp: struct as value, binary; file restored ok +PASS: gdb.base/dump.exp: struct as value, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as value, binary; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array as memory, binary; file restored ok +PASS: gdb.base/dump.exp: array as memory, binary; capture intarray +PASS: gdb.base/dump.exp: array as memory, binary; value restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; file restored ok +PASS: gdb.base/dump.exp: struct as memory, binary; capture intstruct +PASS: gdb.base/dump.exp: struct as memory, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray2[0] +PASS: gdb.base/dump.exp: capture /x &intstruct2 +PASS: gdb.base/dump.exp: capture (char *) &intarray2 - (char *) &intarray +PASS: gdb.base/dump.exp: capture (char *) &intstruct2 - (char *) &intstruct +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, srec; file restored ok +PASS: gdb.base/dump.exp: array copy, srec; capture intarray2 +FAIL: gdb.base/dump.exp: array copy, srec; value restored ok +PASS: gdb.base/dump.exp: struct copy, srec; file restored ok +PASS: gdb.base/dump.exp: struct copy, srec; capture intstruct2 +FAIL: gdb.base/dump.exp: struct copy, srec; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array copy, ihex; file restored ok +PASS: gdb.base/dump.exp: array copy, ihex; capture intarray2 +FAIL: gdb.base/dump.exp: array copy, ihex; value restored ok +FAIL: gdb.base/dump.exp: struct copy, ihex; file restored ok +PASS: gdb.base/dump.exp: struct copy, ihex; capture intstruct2 +FAIL: gdb.base/dump.exp: struct copy, ihex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: array copy, tekhex; capture intarray2 +FAIL: gdb.base/dump.exp: array copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; file restored ok +PASS: gdb.base/dump.exp: struct copy, tekhex; capture intstruct2 +FAIL: gdb.base/dump.exp: struct copy, tekhex; value restored ok +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array copy, binary; file restored ok +PASS: gdb.base/dump.exp: array copy, binary; capture intarray2 +PASS: gdb.base/dump.exp: array copy, binary; value restored ok +PASS: gdb.base/dump.exp: struct copy, binary; file restored ok +PASS: gdb.base/dump.exp: struct copy, binary; capture intstruct2 +PASS: gdb.base/dump.exp: struct copy, binary; value restored ok +PASS: gdb.base/dump.exp: capture /x &intarray[3] +PASS: gdb.base/dump.exp: capture /x &intarray[4] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[3] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: capture /x (char *) &intarray[4] - (char *) &intarray[0] +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array partial, srec; file restored ok +PASS: gdb.base/dump.exp: array partial, srec; capture intarray[3] +FAIL: gdb.base/dump.exp: array partial, srec; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 1 +PASS: gdb.base/dump.exp: element 4 not changed - 1 +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array partial, ihex; file restored ok +PASS: gdb.base/dump.exp: array partial, ihex; capture intarray[3] +FAIL: gdb.base/dump.exp: array partial, ihex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 2 +PASS: gdb.base/dump.exp: element 4 not changed - 2 +PASS: gdb.base/dump.exp: print zero_all () +FAIL: gdb.base/dump.exp: array partial, tekhex; file restored ok +PASS: gdb.base/dump.exp: array partial, tekhex; capture intarray[3] +FAIL: gdb.base/dump.exp: array partial, tekhex; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 3 +PASS: gdb.base/dump.exp: element 4 not changed - 3 +PASS: gdb.base/dump.exp: print zero_all () +PASS: gdb.base/dump.exp: array partial, binary; file restored ok +PASS: gdb.base/dump.exp: array partial, binary; capture intarray[3] +PASS: gdb.base/dump.exp: array partial, binary; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed - 4 +PASS: gdb.base/dump.exp: element 4 not changed - 4 +FAIL: gdb.base/dump.exp: array partial with expressions; file restored ok +PASS: gdb.base/dump.exp: array partial with expressions; capture intarray2[3] +FAIL: gdb.base/dump.exp: array partial with expressions; value restored ok +PASS: gdb.base/dump.exp: element 2 not changed, == 4 +PASS: gdb.base/dump.exp: element 4 not changed, == 4 +PASS: gdb.base/dump.exp: setting little endianness +PASS: gdb.base/dump.exp: file binfile; capture intarray +PASS: gdb.base/dump.exp: start with intarray un-initialized +PASS: gdb.base/dump.exp: file binfile; capture intstruct +PASS: gdb.base/dump.exp: start with intstruct un-initialized +PASS: gdb.base/dump.exp: reload array as value, srec; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, srec; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as value, srec; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, srec; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as memory, srec; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, srec; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as memory, srec; value restored ok +ERROR: Couldn't load intarr1.ihex into /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb. +UNRESOLVED: gdb.base/dump.exp: reload array as value, intel hex; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as value, intel hex; value restored ok +ERROR: Couldn't load intstr1.ihex into /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb. +UNRESOLVED: gdb.base/dump.exp: reload struct as value, intel hex; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as value, intel hex; value restored ok +ERROR: Couldn't load intarr2.ihex into /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb. +UNRESOLVED: gdb.base/dump.exp: reload array as memory, intel hex; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as memory, intel hex; value restored ok +ERROR: Couldn't load intstr2.ihex into /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb. +UNRESOLVED: gdb.base/dump.exp: reload struct as memory, intel hex; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as memory, intel hex; value restored ok +PASS: gdb.base/dump.exp: reload array as value, tekhex; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as value, tekhex; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as value, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload array as memory, tekhex; capture * (int (*)[32]) 0x555555556040 +FAIL: gdb.base/dump.exp: reload array as memory, tekhex; value restored ok +PASS: gdb.base/dump.exp: reload struct as memory, tekhex; capture * (struct teststruct *) 0x555555556140 +FAIL: gdb.base/dump.exp: reload struct as memory, tekhex; value restored ok +Running ./gdb.base/duplicate-bp.exp ... +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: del_1_stop_2: delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: del_2_stop_1: delete #2, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_2_stop_3: disable #1, delete #2, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_1_stop_3: disable #2, delete #1, stop at #3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_1_del_3_stop_1: disable #1, delete #3, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: delete $bp_num_1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_1_stop_2: disable #3, delete #1, stop at #2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: delete $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_2_del_3_stop_1: disable #2, delete #3, stop at #1 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_1 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_2 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: set $bp_num_3 = $bpnum +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step to place breakpoints +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable $bp_num_3 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: step +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: delete $bp_num_2 +PASS: gdb.base/duplicate-bp.exp: dis_3_del_2_stop_1: disable #3, delete #2, stop at #1 +Running ./gdb.base/dup-sect.exp ... +PASS: gdb.base/dup-sect.exp: rename section +PASS: gdb.base/dup-sect.exp: split +PASS: gdb.base/dup-sect.exp: strip +PASS: gdb.base/dup-sect.exp: var1 after strip +PASS: gdb.base/dup-sect.exp: var2 after strip +Running ./gdb.base/echo.exp ... +PASS: gdb.base/echo.exp: Echo test +Running ./gdb.base/empty_exe.exp ... +PASS: gdb.base/empty_exe.exp: file '' +PASS: gdb.base/empty_exe.exp: print 1 +Running ./gdb.base/ena-dis-br.exp ... +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: enable break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +PASS: gdb.base/ena-dis-br.exp: continue to break marker1 +PASS: gdb.base/ena-dis-br.exp: delete break marker1 +PASS: gdb.base/ena-dis-br.exp: break marker2 +PASS: gdb.base/ena-dis-br.exp: enable once break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: info auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at auto-disabled break marker2 +PASS: gdb.base/ena-dis-br.exp: break marker3 +PASS: gdb.base/ena-dis-br.exp: enable del break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker2 +PASS: gdb.base/ena-dis-br.exp: continue to auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: info auto-deleted break marker3 +PASS: gdb.base/ena-dis-br.exp: break marker4 +PASS: gdb.base/ena-dis-br.exp: disable break marker4 +PASS: gdb.base/ena-dis-br.exp: info break marker4 +PASS: gdb.base/ena-dis-br.exp: break 113 +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break with count +PASS: gdb.base/ena-dis-br.exp: continue from enable count, first time +PASS: gdb.base/ena-dis-br.exp: continue from enable count, second time +PASS: gdb.base/ena-dis-br.exp: continue through enable count, now disabled +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore non-existent break +PASS: gdb.base/ena-dis-br.exp: ignore break with missing ignore count +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 -1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 0 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: info ignored break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue to break marker1, 2nd time +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: enable del break marker1 +PASS: gdb.base/ena-dis-br.exp: info break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored & auto-deleted break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: continue to ignored & auto-deleted break marker1 +PASS: gdb.base/ena-dis-br.exp: break marker1 +PASS: gdb.base/ena-dis-br.exp: ignore break marker1 +PASS: gdb.base/ena-dis-br.exp: disable break marker1 +PASS: gdb.base/ena-dis-br.exp: continue until exit at no stop at ignored & disabled break marker1 +PASS: gdb.base/ena-dis-br.exp: rerun to main +PASS: gdb.base/ena-dis-br.exp: info ignored & disabled break marker1 +PASS: gdb.base/ena-dis-br.exp: prepare to continue with ignore count +PASS: gdb.base/ena-dis-br.exp: continue with ignore count +PASS: gdb.base/ena-dis-br.exp: step +PASS: gdb.base/ena-dis-br.exp: continue with ignore count, not stopped at bpt +Running ./gdb.base/ending-run.exp ... +PASS: gdb.base/ending-run.exp: bpt at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:14, one +PASS: gdb.base/ending-run.exp: b ending-run.c:31 +PASS: gdb.base/ending-run.exp: run +PASS: gdb.base/ending-run.exp: clear worked +PASS: gdb.base/ending-run.exp: cleared bp at line before routine +PASS: gdb.base/ending-run.exp: b ending-run.c:1 +PASS: gdb.base/ending-run.exp: b ending-run.c:14, two +PASS: gdb.base/ending-run.exp: Cleared 2 by line +PASS: gdb.base/ending-run.exp: b ending-run.c:14 +PASS: gdb.base/ending-run.exp: Breakpoint 7 at *ending-run.c:14 +PASS: gdb.base/ending-run.exp: Clear 2 by default +PASS: gdb.base/ending-run.exp: all set to continue +PASS: gdb.base/ending-run.exp: cont +PASS: gdb.base/ending-run.exp: step out of main +Running ./gdb.base/enum_cond.exp ... +PASS: gdb.base/enum_cond.exp: break call_me if param.e == 1 +PASS: gdb.base/enum_cond.exp: continue to conditional breakpoint in call_me +Running ./gdb.base/enumval.exp ... +PASS: gdb.base/enumval.exp: print e +PASS: gdb.base/enumval.exp: print f +PASS: gdb.base/enumval.exp: print J +PASS: gdb.base/enumval.exp: print K +Running ./gdb.base/environ.exp ... +Running ./gdb.base/eu-strip-infcall.exp ... +PASS: gdb.base/eu-strip-infcall.exp: infcall +Running ./gdb.base/eval.exp ... +PASS: gdb.base/eval.exp: Initialize $a. +PASS: gdb.base/eval.exp: First eval. +PASS: gdb.base/eval.exp: Second eval. +Running ./gdb.base/eval-skip.exp ... +PASS: gdb.base/eval-skip.exp: set variable x=14 +PASS: gdb.base/eval-skip.exp: set variable y=2 +PASS: gdb.base/eval-skip.exp: set variable z=2 +PASS: gdb.base/eval-skip.exp: set variable w=3 +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x-y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x*y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x/y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x%y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x||y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x&y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x|y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x^y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x < y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x <= y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x==y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x!=y)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x<<31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x>>31)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (!x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (~x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (-x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x++)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (++x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x--)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (--x)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x+=7)) +PASS: gdb.base/eval-skip.exp: print value of (0 && (x=y)) +Running ./gdb.base/exe-lock.exp ... +PASS: gdb.base/exe-lock.exp: continue until exit +Running ./gdb.base/expand-psymtabs.exp ... +PASS: gdb.base/expand-psymtabs.exp: Expand psymtabs +Running ./gdb.base/exprs.exp ... +PASS: gdb.base/exprs.exp: print char == (setup) +PASS: gdb.base/exprs.exp: print char == (print v_char == 0) +PASS: gdb.base/exprs.exp: print char == (print v_char == 127) +PASS: gdb.base/exprs.exp: print char != (setup) +PASS: gdb.base/exprs.exp: print char != (print v_char != 0) +PASS: gdb.base/exprs.exp: print char != (print v_char != 127) +PASS: gdb.base/exprs.exp: print char < (setup) +PASS: gdb.base/exprs.exp: print char < (print v_char < 0) +PASS: gdb.base/exprs.exp: print char < (print v_char < 127) +PASS: gdb.base/exprs.exp: print char > (setup) +PASS: gdb.base/exprs.exp: print char > (print v_char > 0) +PASS: gdb.base/exprs.exp: print char > (print v_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (setup) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (print v_signed_char == 127) +PASS: gdb.base/exprs.exp: print signed char != (setup) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (print v_signed_char != 127) +PASS: gdb.base/exprs.exp: print signed char < (setup) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (setup) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print signed char == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == 0) +PASS: gdb.base/exprs.exp: print signed char == (minus) (print v_signed_char == -1) +PASS: gdb.base/exprs.exp: print signed char != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != 0) +PASS: gdb.base/exprs.exp: print signed char != (minus) (print v_signed_char != -1) +PASS: gdb.base/exprs.exp: print signed char < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 0) +PASS: gdb.base/exprs.exp: print signed char < (minus) (print v_signed_char < 127) +PASS: gdb.base/exprs.exp: print signed char > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 0) +PASS: gdb.base/exprs.exp: print signed char > (minus) (print v_signed_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (print v_unsigned_char == 127) +PASS: gdb.base/exprs.exp: print unsigned char != (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (print v_unsigned_char != 127) +PASS: gdb.base/exprs.exp: print unsigned char < (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == 0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == ~0) +PASS: gdb.base/exprs.exp: print unsigned char == (~0) (print v_unsigned_char == (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != 0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != (unsigned char)~0) +PASS: gdb.base/exprs.exp: print unsigned char != (~0) (print v_unsigned_char != ~0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 0) +PASS: gdb.base/exprs.exp: print unsigned char < (~0) (print v_unsigned_char < 127) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 0) +PASS: gdb.base/exprs.exp: print unsigned char > (~0) (print v_unsigned_char > 127) +PASS: gdb.base/exprs.exp: print signed short == (setup) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (print v_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short != (setup) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (print v_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short < (setup) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (setup) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == 0) +PASS: gdb.base/exprs.exp: print signed short == (minus) (print v_short == -1) +PASS: gdb.base/exprs.exp: print signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != 0) +PASS: gdb.base/exprs.exp: print signed short != (minus) (print v_short != -1) +PASS: gdb.base/exprs.exp: print signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0) +PASS: gdb.base/exprs.exp: print signed short < (minus) (print v_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0) +PASS: gdb.base/exprs.exp: print signed short > (minus) (print v_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (print v_signed_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short != (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (print v_signed_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short < (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == 0) +PASS: gdb.base/exprs.exp: print signed signed short == (minus) (print v_signed_short == -1) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != 0) +PASS: gdb.base/exprs.exp: print signed signed short != (minus) (print v_signed_short != -1) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0) +PASS: gdb.base/exprs.exp: print signed signed short < (minus) (print v_signed_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0) +PASS: gdb.base/exprs.exp: print signed signed short > (minus) (print v_signed_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (print v_unsigned_short == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short != (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (print v_unsigned_short != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short < (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == 0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print sizeof (v_unsigned_short) < sizeof (~0) && v_unsigned_short == ~0) +PASS: gdb.base/exprs.exp: print unsigned short == (~0) (print v_unsigned_short == (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != 0) +PASS: gdb.base/exprs.exp: print unsigned short != (~0) (print v_unsigned_short != (unsigned short)~0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0) +PASS: gdb.base/exprs.exp: print unsigned short < (~0) (print v_unsigned_short < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0) +PASS: gdb.base/exprs.exp: print unsigned short > (~0) (print v_unsigned_short > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (setup) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (print v_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int != (setup) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (print v_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int < (setup) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (setup) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == 0) +PASS: gdb.base/exprs.exp: print signed int == (minus) (print v_int == -1) +PASS: gdb.base/exprs.exp: print signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != 0) +PASS: gdb.base/exprs.exp: print signed int != (minus) (print v_int != -1) +PASS: gdb.base/exprs.exp: print signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0) +PASS: gdb.base/exprs.exp: print signed int < (minus) (print v_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0) +PASS: gdb.base/exprs.exp: print signed int > (minus) (print v_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (print v_signed_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int != (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (print v_signed_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int < (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == 0) +PASS: gdb.base/exprs.exp: print signed signed int == (minus) (print v_signed_int == -1) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != 0) +PASS: gdb.base/exprs.exp: print signed signed int != (minus) (print v_signed_int != -1) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0) +PASS: gdb.base/exprs.exp: print signed signed int < (minus) (print v_signed_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0) +PASS: gdb.base/exprs.exp: print signed signed int > (minus) (print v_signed_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (print v_unsigned_int == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int != (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (print v_unsigned_int != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int < (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == 0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == ~0) +PASS: gdb.base/exprs.exp: print unsigned int == (~0) (print v_unsigned_int == (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != 0) +PASS: gdb.base/exprs.exp: print unsigned int != (~0) (print v_unsigned_int != (unsigned int)~0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0) +PASS: gdb.base/exprs.exp: print unsigned int < (~0) (print v_unsigned_int < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0) +PASS: gdb.base/exprs.exp: print unsigned int > (~0) (print v_unsigned_int > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (setup) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (print v_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long != (setup) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (print v_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long < (setup) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (setup) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == 0) +PASS: gdb.base/exprs.exp: print signed long == (minus) (print v_long == -1) +PASS: gdb.base/exprs.exp: print signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != 0) +PASS: gdb.base/exprs.exp: print signed long != (minus) (print v_long != -1) +PASS: gdb.base/exprs.exp: print signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0) +PASS: gdb.base/exprs.exp: print signed long < (minus) (print v_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0) +PASS: gdb.base/exprs.exp: print signed long > (minus) (print v_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (print v_signed_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long != (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (print v_signed_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long < (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == 0) +PASS: gdb.base/exprs.exp: print signed signed long == (minus) (print v_signed_long == -1) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != 0) +PASS: gdb.base/exprs.exp: print signed signed long != (minus) (print v_signed_long != -1) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0) +PASS: gdb.base/exprs.exp: print signed signed long < (minus) (print v_signed_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (setup) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0) +PASS: gdb.base/exprs.exp: print signed signed long > (minus) (print v_signed_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (print v_unsigned_long == 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long != (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (print v_unsigned_long != 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long < (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == 0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == ~0) +PASS: gdb.base/exprs.exp: print unsigned long == (~0) (print v_unsigned_long == (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != 0) +PASS: gdb.base/exprs.exp: print unsigned long != (~0) (print v_unsigned_long != (unsigned long)~0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0) +PASS: gdb.base/exprs.exp: print unsigned long < (~0) (print v_unsigned_long < 0x7FFF) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (setup) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0) +PASS: gdb.base/exprs.exp: print unsigned long > (~0) (print v_unsigned_long > 0x7FFF) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_char (print (void*)v_signed_char) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_short (print (void*)v_signed_short) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_int (print (void*)v_signed_int) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_signed_long (print (void*)v_signed_long) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_char (print (void*)v_unsigned_char) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_short (print (void*)v_unsigned_short) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_int (print (void*)v_unsigned_int) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (setup) +PASS: gdb.base/exprs.exp: print (void*)v_unsigned_long (print (void*)v_unsigned_long) +PASS: gdb.base/exprs.exp: sizeof (long long) > sizeof (long) (false) +XFAIL: gdb.base/exprs.exp: truncate (void*) 0x00000000ffffffff + 1 +XFAIL: gdb.base/exprs.exp: truncate (void*) 0xffffffff00000000 - 1 +PASS: gdb.base/exprs.exp: \$[0-9]* = "xy" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = "xyz" (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: set output-radix 8 +PASS: gdb.base/exprs.exp: \$[0-9]* = red (setup) +PASS: gdb.base/exprs.exp: \$[0-9]* = 0 (setup) +PASS: gdb.base/exprs.exp: set output-radix 10 +PASS: gdb.base/exprs.exp: set variable v_int = 1 +PASS: gdb.base/exprs.exp: print v_int++ +PASS: gdb.base/exprs.exp: print ++v_int +PASS: gdb.base/exprs.exp: print v_int-- +PASS: gdb.base/exprs.exp: print --v_int +PASS: gdb.base/exprs.exp: print v_int++ = 5 +PASS: gdb.base/exprs.exp: print v_int-- = 5 +PASS: gdb.base/exprs.exp: print v_int_array_init +PASS: gdb.base/exprs.exp: print *v_int_array_init@1 +PASS: gdb.base/exprs.exp: print *v_int_array_init@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@1 +PASS: gdb.base/exprs.exp: print v_int_array_init[0]@2 +PASS: gdb.base/exprs.exp: print v_int_array_init[1]@1 +PASS: gdb.base/exprs.exp: set variable v_short_array[0] = 42 +PASS: gdb.base/exprs.exp: print {short} v_short_array +PASS: gdb.base/exprs.exp: print (void) v_int_pointer +PASS: gdb.base/exprs.exp: print & (void) v_char +Running ./gdb.base/fileio.exp ... +Running ./gdb.base/find.exp ... +PASS: gdb.base/find.exp: breakpoint function in file +PASS: gdb.base/find.exp: run until function breakpoint +PASS: gdb.base/find.exp: find string pattern +PASS: gdb.base/find.exp: pattern not found at end of range +PASS: gdb.base/find.exp: pattern found at end of range +PASS: gdb.base/find.exp: max-count +PASS: gdb.base/find.exp: $_ +PASS: gdb.base/find.exp: $numfound +PASS: gdb.base/find.exp: size,max-count, /1b +PASS: gdb.base/find.exp: size,max-count, /b1 +PASS: gdb.base/find.exp: size,max-count, /b/1 +PASS: gdb.base/find.exp: size,max-count, /1/b +PASS: gdb.base/find.exp: find byte pattern with end address +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 16-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 32-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find 64-bit pattern +PASS: gdb.base/find.exp: find mixed-sized pattern +PASS: gdb.base/find.exp: search spanning large range +PASS: gdb.base/find.exp: find int64_search_buf, +64/8*100, int64_search_buf +Running ./gdb.base/find-unmapped.exp ... +Running ./gdb.base/finish.exp ... +PASS: gdb.base/finish.exp: set break on void_func +PASS: gdb.base/finish.exp: continue to void_func +PASS: gdb.base/finish.exp: finish from void_func +PASS: gdb.base/finish.exp: set break on char_func +PASS: gdb.base/finish.exp: continue to char_func +PASS: gdb.base/finish.exp: finish from char_func +PASS: gdb.base/finish.exp: set break on short_func +PASS: gdb.base/finish.exp: continue to short_func +PASS: gdb.base/finish.exp: finish from short_func +PASS: gdb.base/finish.exp: set break on int_func +PASS: gdb.base/finish.exp: continue to int_func +PASS: gdb.base/finish.exp: finish from int_func +PASS: gdb.base/finish.exp: set break on long_func +PASS: gdb.base/finish.exp: continue to long_func +PASS: gdb.base/finish.exp: finish from long_func +PASS: gdb.base/finish.exp: set break on long_long_func +PASS: gdb.base/finish.exp: continue to long_long_func +PASS: gdb.base/finish.exp: finish from long_long_func +PASS: gdb.base/finish.exp: set break on float_func +PASS: gdb.base/finish.exp: continue to float_func +PASS: gdb.base/finish.exp: finish from float_func +PASS: gdb.base/finish.exp: set break on double_func +PASS: gdb.base/finish.exp: continue to double_func +PASS: gdb.base/finish.exp: finish from double_func +PASS: gdb.base/finish.exp: Testing the "fin" abbreviation for "finish" +Running ./gdb.base/fixsection.exp ... +PASS: gdb.base/fixsection.exp: breakpoint at static_fun +Running ./gdb.base/float.exp ... +PASS: gdb.base/float.exp: info float +PASS: gdb.base/float.exp: step +PASS: gdb.base/float.exp: finish +Running ./gdb.base/foll-exec.exp ... +Running ./gdb.base/foll-fork.exp ... +Running ./gdb.base/foll-vfork.exp ... +Running ./gdb.base/fortran-sym-case.exp ... +PASS: gdb.base/fortran-sym-case.exp: set language fortran +PASS: gdb.base/fortran-sym-case.exp: frame +Running ./gdb.base/frame-args.exp ... +PASS: gdb.base/frame-args.exp: set print frame-arguments all +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to all +PASS: gdb.base/frame-args.exp: set print frame-arguments scalars +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to scalars +PASS: gdb.base/frame-args.exp: set print frame-arguments none +PASS: gdb.base/frame-args.exp: frame 1 with print frame-arguments set to none +Running ./gdb.base/freebpcmd.exp ... +PASS: gdb.base/freebpcmd.exp: set breakpoint +PASS: gdb.base/freebpcmd.exp: send breakpoint commands +PASS: gdb.base/freebpcmd.exp: run program with breakpoint commands +Running ./gdb.base/fullname.exp ... +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint at main - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built absolute +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint at main - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built relative +PASS: gdb.base/fullname.exp: set breakpoint by full path before loading symbols - built other +PASS: gdb.base/fullname.exp: set breakpoint at main - built other +PASS: gdb.base/fullname.exp: set breakpoint by full path after loading symbols - built other +Running ./gdb.base/fullpath-expand.exp ... +PASS: gdb.base/fullpath-expand.exp: rbreak XXX/fullpath-expand-func.c:func +PASS: gdb.base/fullpath-expand.exp: list func +PASS: gdb.base/fullpath-expand.exp: info source +Running ./gdb.base/funcargs.exp ... +PASS: gdb.base/funcargs.exp: set print frame-arguments all +PASS: gdb.base/funcargs.exp: run to call0a +PASS: gdb.base/funcargs.exp: print c after run to call0a +PASS: gdb.base/funcargs.exp: print s after run to call0a +PASS: gdb.base/funcargs.exp: print i after run to call0a +PASS: gdb.base/funcargs.exp: print l after run to call0a +PASS: gdb.base/funcargs.exp: continue to call0b +PASS: gdb.base/funcargs.exp: continue to call0c +PASS: gdb.base/funcargs.exp: continue to call0d +PASS: gdb.base/funcargs.exp: continue to call0e +PASS: gdb.base/funcargs.exp: run to call1a +PASS: gdb.base/funcargs.exp: print uc +PASS: gdb.base/funcargs.exp: print us +PASS: gdb.base/funcargs.exp: print ui +PASS: gdb.base/funcargs.exp: print ul +PASS: gdb.base/funcargs.exp: continue to call1b +PASS: gdb.base/funcargs.exp: continue to call1c +PASS: gdb.base/funcargs.exp: continue to call1d +PASS: gdb.base/funcargs.exp: continue to call1e +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: print c after run to call2a +PASS: gdb.base/funcargs.exp: print f1 after run to call2a +PASS: gdb.base/funcargs.exp: print s after run to call2a +PASS: gdb.base/funcargs.exp: print d1 after run to call2a +PASS: gdb.base/funcargs.exp: print i after run to call2a +PASS: gdb.base/funcargs.exp: print f2 after run to call2a +PASS: gdb.base/funcargs.exp: print l after run to call2a +PASS: gdb.base/funcargs.exp: print d2 after run to call2a +PASS: gdb.base/funcargs.exp: continue to call2b +PASS: gdb.base/funcargs.exp: continue to call2c +PASS: gdb.base/funcargs.exp: continue to call2d +PASS: gdb.base/funcargs.exp: continue to call2e +PASS: gdb.base/funcargs.exp: continue to call2f +PASS: gdb.base/funcargs.exp: continue to call2g +PASS: gdb.base/funcargs.exp: continue to call2h +PASS: gdb.base/funcargs.exp: continue to call2i +PASS: gdb.base/funcargs.exp: run to call2a +PASS: gdb.base/funcargs.exp: continue to callcb +PASS: gdb.base/funcargs.exp: continue to callcc +PASS: gdb.base/funcargs.exp: continue to callcd +PASS: gdb.base/funcargs.exp: continue to callce +PASS: gdb.base/funcargs.exp: continue to callcf +PASS: gdb.base/funcargs.exp: run to callc1a +PASS: gdb.base/funcargs.exp: continue to callc1b +PASS: gdb.base/funcargs.exp: run to callc2a +PASS: gdb.base/funcargs.exp: continue to callc2b +PASS: gdb.base/funcargs.exp: run to call3a +PASS: gdb.base/funcargs.exp: print *cp +PASS: gdb.base/funcargs.exp: print *sp +PASS: gdb.base/funcargs.exp: print *ip +PASS: gdb.base/funcargs.exp: print *lp +PASS: gdb.base/funcargs.exp: continue to call3b +PASS: gdb.base/funcargs.exp: print *ucp +PASS: gdb.base/funcargs.exp: print *usp +PASS: gdb.base/funcargs.exp: print *uip +PASS: gdb.base/funcargs.exp: print *ulp +PASS: gdb.base/funcargs.exp: continue to call3c +PASS: gdb.base/funcargs.exp: print *fp +PASS: gdb.base/funcargs.exp: print *dp +PASS: gdb.base/funcargs.exp: run to call4a +PASS: gdb.base/funcargs.exp: print *stp +PASS: gdb.base/funcargs.exp: continue to call4b +PASS: gdb.base/funcargs.exp: print *unp (little-endian, sizeof long != sizeof int) +PASS: gdb.base/funcargs.exp: locate actual args, structs/unions passed by reference +PASS: gdb.base/funcargs.exp: run to call5a +PASS: gdb.base/funcargs.exp: print st +PASS: gdb.base/funcargs.exp: continue to call5b (little-endian, sizeof long != sizeof int) +PASS: gdb.base/funcargs.exp: print un (little-endian, sizeof long != sizeof int) +PASS: gdb.base/funcargs.exp: run to call6a +PASS: gdb.base/funcargs.exp: backtrace from call6a +PASS: gdb.base/funcargs.exp: continue to call6b +PASS: gdb.base/funcargs.exp: backtrace from call6b +PASS: gdb.base/funcargs.exp: continue to call6c +PASS: gdb.base/funcargs.exp: backtrace from call6c +PASS: gdb.base/funcargs.exp: continue to call6d +PASS: gdb.base/funcargs.exp: backtrace from call6d +PASS: gdb.base/funcargs.exp: continue to call6e +PASS: gdb.base/funcargs.exp: backtrace from call6e +PASS: gdb.base/funcargs.exp: continue to call6f +PASS: gdb.base/funcargs.exp: backtrace from call6f +PASS: gdb.base/funcargs.exp: continue to call6g +PASS: gdb.base/funcargs.exp: backtrace from call6g +PASS: gdb.base/funcargs.exp: continue to call6h +PASS: gdb.base/funcargs.exp: backtrace from call6h +PASS: gdb.base/funcargs.exp: continue to call6i +PASS: gdb.base/funcargs.exp: backtrace from call6i +PASS: gdb.base/funcargs.exp: continue to call6j +PASS: gdb.base/funcargs.exp: backtrace from call6j +PASS: gdb.base/funcargs.exp: continue to call6k +PASS: gdb.base/funcargs.exp: backtrace from call6k +PASS: gdb.base/funcargs.exp: run to call7a +PASS: gdb.base/funcargs.exp: backtrace from call7a +PASS: gdb.base/funcargs.exp: continue to call7b +PASS: gdb.base/funcargs.exp: backtrace from call7b +PASS: gdb.base/funcargs.exp: continue to call7c +PASS: gdb.base/funcargs.exp: backtrace from call7c +PASS: gdb.base/funcargs.exp: continue to call7d +PASS: gdb.base/funcargs.exp: backtrace from call7d +PASS: gdb.base/funcargs.exp: continue to call7e +PASS: gdb.base/funcargs.exp: backtrace from call7e +PASS: gdb.base/funcargs.exp: continue to call7f +PASS: gdb.base/funcargs.exp: backtrace from call7f +PASS: gdb.base/funcargs.exp: continue to call7g +PASS: gdb.base/funcargs.exp: backtrace from call7g +PASS: gdb.base/funcargs.exp: continue to call7h +PASS: gdb.base/funcargs.exp: backtrace from call7h +PASS: gdb.base/funcargs.exp: continue to call7i +PASS: gdb.base/funcargs.exp: backtrace from call7i +PASS: gdb.base/funcargs.exp: continue to call7j +PASS: gdb.base/funcargs.exp: backtrace from call7j +PASS: gdb.base/funcargs.exp: continue to call7k +PASS: gdb.base/funcargs.exp: backtrace from call7k +PASS: gdb.base/funcargs.exp: run to hitbottom +PASS: gdb.base/funcargs.exp: recursive passing of structs by value +PASS: gdb.base/funcargs.exp: print c after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l after runto localvars_after_alloca +PASS: gdb.base/funcargs.exp: next in localvars_after_alloca() +PASS: gdb.base/funcargs.exp: print c in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print s in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print i in localvars_after_alloca +PASS: gdb.base/funcargs.exp: print l in localvars_after_alloca +PASS: gdb.base/funcargs.exp: backtrace after alloca +PASS: gdb.base/funcargs.exp: print c in call_after_alloca +PASS: gdb.base/funcargs.exp: print s in call_after_alloca +PASS: gdb.base/funcargs.exp: print i in call_after_alloca +PASS: gdb.base/funcargs.exp: print l in call_after_alloca +PASS: gdb.base/funcargs.exp: backtrace from call_after_alloca_subr +PASS: gdb.base/funcargs.exp: continue to call0a +PASS: gdb.base/funcargs.exp: print c in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print s in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print i in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: print l in localvars_in_indirect_call +PASS: gdb.base/funcargs.exp: backtrace in indirectly called function +PASS: gdb.base/funcargs.exp: finish from indirectly called function +PASS: gdb.base/funcargs.exp: stepping into indirectly called function +PASS: gdb.base/funcargs.exp: finish from marker_call_with_trampolines +PASS: gdb.base/funcargs.exp: stepping into function called with trampolines +PASS: gdb.base/funcargs.exp: backtrace through call with trampolines +PASS: gdb.base/funcargs.exp: stepping back to main from function called with trampolines +Running ./gdb.base/gcore-buffer-overflow.exp ... +PASS: gdb.base/gcore-buffer-overflow.exp: help gcore +PASS: gdb.base/gcore-buffer-overflow.exp: Set buffer exceeding arguments +PASS: gdb.base/gcore-buffer-overflow.exp: save a corefile +Running ./gdb.base/gcore.exp ... +PASS: gdb.base/gcore.exp: help gcore +PASS: gdb.base/gcore.exp: set breakpoint at terminal_func +PASS: gdb.base/gcore.exp: continue to terminal_func +PASS: gdb.base/gcore.exp: save a corefile +FAIL: gdb.base/gcore.exp: re-load generated corefile (bad file format) +Running ./gdb.base/gcore-relro.exp ... +PASS: gdb.base/gcore-relro.exp: help gcore +PASS: gdb.base/gcore-relro.exp: save a corefile +FAIL: gdb.base/gcore-relro.exp: re-load generated corefile +FAIL: gdb.base/gcore-relro.exp: library got loaded +Running ./gdb.base/gdb1056.exp ... +PASS: gdb.base/gdb1056.exp: print 1/0 +PASS: gdb.base/gdb1056.exp: Test unsigned division by zero +Running ./gdb.base/gdb1090.exp ... +PASS: gdb.base/gdb1090.exp: continue to breakpoint: break-here +PASS: gdb.base/gdb1090.exp: print s24 +Running ./gdb.base/gdb11530.exp ... +PASS: gdb.base/gdb11530.exp: print a.i +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) +PASS: gdb.base/gdb11530.exp: print sizeof (a.i) == sizeof (int) +Running ./gdb.base/gdb11531.exp ... +PASS: gdb.base/gdb11531.exp: Set watchpoint +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at next +PASS: gdb.base/gdb11531.exp: watchpoint variable triggers at continue +Running ./gdb.base/gdb1250.exp ... +PASS: gdb.base/gdb1250.exp: backtrace from abort +Running ./gdb.base/gdb1555.exp ... +PASS: gdb.base/gdb1555.exp: Step into shared lib function +PASS: gdb.base/gdb1555.exp: Next while in a shared lib function +Running ./gdb.base/gdb1821.exp ... +PASS: gdb.base/gdb1821.exp: print /x bar +Running ./gdb.base/gdbindex-stabs.exp ... +PASS: gdb.base/gdbindex-stabs.exp: list stabs_function +Running ./gdb.base/gdbvars.exp ... +PASS: gdb.base/gdbvars.exp: set print sevenbit-strings +PASS: gdb.base/gdbvars.exp: Set value-history[1] using $1 +PASS: gdb.base/gdbvars.exp: Set value-history[2] using $2 +PASS: gdb.base/gdbvars.exp: Set value-history[3] using $3 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.base/gdbvars.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.base/gdbvars.exp: print 108 +PASS: gdb.base/gdbvars.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.base/gdbvars.exp: Print value-history[1] using explicit index $1 +PASS: gdb.base/gdbvars.exp: Print value-history[2] using explicit index $2 +PASS: gdb.base/gdbvars.exp: Print value-history[3] using explicit index $3 +PASS: gdb.base/gdbvars.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.base/gdbvars.exp: Use value-history element in arithmetic expression +PASS: gdb.base/gdbvars.exp: Set a new convenience variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable to a new value +PASS: gdb.base/gdbvars.exp: Print new contents of convenience variable +PASS: gdb.base/gdbvars.exp: Set convenience variable $_ +PASS: gdb.base/gdbvars.exp: Print contents of convenience variable $_ +PASS: gdb.base/gdbvars.exp: Use convenience variable in arithmetic expression +PASS: gdb.base/gdbvars.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.base/gdbvars.exp: Print contents of uninitialized convenience variable +PASS: gdb.base/gdbvars.exp: Set a new convenience variable to a program variable +PASS: gdb.base/gdbvars.exp: Print contents of new convenience variable of program variable +Running ./gdb.base/gnu-debugdata.exp ... +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke x86_64-cros-linux-gnu-nm +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm -D - invoke sort +PASS: gdb.base/gnu-debugdata.exp: nm - invoke x86_64-cros-linux-gnu-nm +PASS: gdb.base/gnu-debugdata.exp: nm - invoke awk +PASS: gdb.base/gnu-debugdata.exp: nm - invoke sort +PASS: gdb.base/gnu-debugdata.exp: comm +PASS: gdb.base/gnu-debugdata.exp: objcopy 1 +PASS: gdb.base/gnu-debugdata.exp: strip +PASS: gdb.base/gnu-debugdata.exp: copydebug +PASS: gdb.base/gnu-debugdata.exp: addlink +PASS: gdb.base/gnu-debugdata.exp: xz +PASS: gdb.base/gnu-debugdata.exp: objcopy 2 +PASS: gdb.base/gnu-debugdata.exp: no symtab +PASS: gdb.base/gnu-debugdata.exp: have symtab +PASS: gdb.base/gnu-debugdata.exp: unload MiniDebugInfo +Running ./gdb.base/gnu-ifunc.exp ... +PASS: gdb.base/gnu-ifunc.exp: continue to breakpoint: break-at-call +FAIL: gdb.base/gnu-ifunc.exp: p gnu_ifunc (3) +FAIL: gdb.base/gnu-ifunc.exp: step +FAIL: gdb.base/gnu-ifunc.exp: continue to break-at-nextcall +FAIL: gdb.base/gnu-ifunc.exp: continue to breakpoint: nextcall gnu_ifunc +FAIL: gdb.base/gnu-ifunc.exp: nextcall gnu_ifunc skipped +PASS: gdb.base/gnu-ifunc.exp: p gnu_ifunc executing +PASS: gdb.base/gnu-ifunc.exp: info sym gnu_ifunc executing +PASS: gdb.base/gnu-ifunc.exp: info addr gnu_ifunc +PASS: gdb.base/gnu-ifunc.exp: info sym <gnu_ifunc-address> +PASS: gdb.base/gnu-ifunc.exp: static gnu_ifunc +Running ./gdb.base/gnu_vector.exp ... +PASS: gdb.base/gnu_vector.exp: print c4 +PASS: gdb.base/gnu_vector.exp: print c4[2] +PASS: gdb.base/gnu_vector.exp: print i4a +PASS: gdb.base/gnu_vector.exp: print i4b +PASS: gdb.base/gnu_vector.exp: print i4a + i4b +PASS: gdb.base/gnu_vector.exp: print i4a - i4b +PASS: gdb.base/gnu_vector.exp: print i4a * i4b +PASS: gdb.base/gnu_vector.exp: print i4a / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % i4b +PASS: gdb.base/gnu_vector.exp: print i4a++ +PASS: gdb.base/gnu_vector.exp: print ++i4a +PASS: gdb.base/gnu_vector.exp: print i4a-- +PASS: gdb.base/gnu_vector.exp: print --i4a +PASS: gdb.base/gnu_vector.exp: print +i4a +PASS: gdb.base/gnu_vector.exp: print -i4a +PASS: gdb.base/gnu_vector.exp: print i4a & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | i4b +PASS: gdb.base/gnu_vector.exp: print i4a ^ i4b +PASS: gdb.base/gnu_vector.exp: print ~i4a +PASS: gdb.base/gnu_vector.exp: print i4a << i4b +PASS: gdb.base/gnu_vector.exp: print i4a >> i4b +PASS: gdb.base/gnu_vector.exp: print f4a +PASS: gdb.base/gnu_vector.exp: print f4b +PASS: gdb.base/gnu_vector.exp: print f4a + f4b +PASS: gdb.base/gnu_vector.exp: print f4a - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * f4b +PASS: gdb.base/gnu_vector.exp: print f4a / f4b +PASS: gdb.base/gnu_vector.exp: print +f4a +PASS: gdb.base/gnu_vector.exp: print -f4a +PASS: gdb.base/gnu_vector.exp: print (char4) 0x01010101 +PASS: gdb.base/gnu_vector.exp: print (char4) ia +PASS: gdb.base/gnu_vector.exp: print (int2) lla +PASS: gdb.base/gnu_vector.exp: print (int2) 1 +PASS: gdb.base/gnu_vector.exp: print (longlong2) 2 +PASS: gdb.base/gnu_vector.exp: print (float2) 3 +PASS: gdb.base/gnu_vector.exp: print (double2) 4 +PASS: gdb.base/gnu_vector.exp: print (uint4) ia +PASS: gdb.base/gnu_vector.exp: print (int4) -3 +PASS: gdb.base/gnu_vector.exp: print (float4) 4 +PASS: gdb.base/gnu_vector.exp: print i4b = ia +PASS: gdb.base/gnu_vector.exp: print i4a = 3 +PASS: gdb.base/gnu_vector.exp: print f4a = fb +PASS: gdb.base/gnu_vector.exp: print f4b = 2 +PASS: gdb.base/gnu_vector.exp: print c4 + lla +PASS: gdb.base/gnu_vector.exp: print i4a + lla +PASS: gdb.base/gnu_vector.exp: print lla + c4 +PASS: gdb.base/gnu_vector.exp: print lla + i4a +PASS: gdb.base/gnu_vector.exp: print c4 + ib +PASS: gdb.base/gnu_vector.exp: print i4a + ib +PASS: gdb.base/gnu_vector.exp: print i4a + 1 +PASS: gdb.base/gnu_vector.exp: print 1 + i4a +PASS: gdb.base/gnu_vector.exp: print fa - f4b +PASS: gdb.base/gnu_vector.exp: print 2 - f4b +PASS: gdb.base/gnu_vector.exp: print f4a * fb +PASS: gdb.base/gnu_vector.exp: print f4a * 1 +PASS: gdb.base/gnu_vector.exp: print ia / i4b +PASS: gdb.base/gnu_vector.exp: print 2 / i4b +PASS: gdb.base/gnu_vector.exp: print i4a % ib +PASS: gdb.base/gnu_vector.exp: print i4a % 1 +PASS: gdb.base/gnu_vector.exp: print ia & i4b +PASS: gdb.base/gnu_vector.exp: print 2 & i4b +PASS: gdb.base/gnu_vector.exp: print i4a | ib +PASS: gdb.base/gnu_vector.exp: print i4a | 1 +PASS: gdb.base/gnu_vector.exp: print ia ^ i4b +PASS: gdb.base/gnu_vector.exp: print 2 ^ i4b +PASS: gdb.base/gnu_vector.exp: print i4a << ib +PASS: gdb.base/gnu_vector.exp: print i4a << 1 +PASS: gdb.base/gnu_vector.exp: print i4a >> ib +PASS: gdb.base/gnu_vector.exp: print i4a >> 1 +PASS: gdb.base/gnu_vector.exp: print i4a = {2, 4, 8, 16} +PASS: gdb.base/gnu_vector.exp: print i4a <<= ib +PASS: gdb.base/gnu_vector.exp: print i4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + f4a +PASS: gdb.base/gnu_vector.exp: print i2 + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i2 +PASS: gdb.base/gnu_vector.exp: print i4a + ll2 +PASS: gdb.base/gnu_vector.exp: print ll2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + d2 +PASS: gdb.base/gnu_vector.exp: print d2 + f4a +PASS: gdb.base/gnu_vector.exp: print ui4 + i4a +PASS: gdb.base/gnu_vector.exp: print i4a + ui4 +PASS: gdb.base/gnu_vector.exp: print i4a + i2 +PASS: gdb.base/gnu_vector.exp: print i2 + i4a +PASS: gdb.base/gnu_vector.exp: print f4a + f2 +PASS: gdb.base/gnu_vector.exp: print f2 + f4a +PASS: gdb.base/gnu_vector.exp: print (double2) f2 +PASS: gdb.base/gnu_vector.exp: print (int4) c4 +PASS: gdb.base/gnu_vector.exp: print (char4) i4a +PASS: gdb.base/gnu_vector.exp: ptype c4 +PASS: gdb.base/gnu_vector.exp: ptype char4 +PASS: gdb.base/gnu_vector.exp: ptype i4a +PASS: gdb.base/gnu_vector.exp: ptype int4 +PASS: gdb.base/gnu_vector.exp: ptype f4b +PASS: gdb.base/gnu_vector.exp: ptype float4 +PASS: gdb.base/gnu_vector.exp: ptype union_with_vector_1 +PASS: gdb.base/gnu_vector.exp: ptype struct_with_vector_1 +Running ./gdb.base/hashline1.exp ... +PASS: gdb.base/hashline1.exp: set breakpoint +Running ./gdb.base/hashline2.exp ... +PASS: gdb.base/hashline2.exp: set breakpoint +Running ./gdb.base/hashline3.exp ... +PASS: gdb.base/hashline3.exp: set breakpoint +Running ./gdb.base/hbreak2.exp ... +PASS: gdb.base/hbreak2.exp: hardware breakpoint support +PASS: gdb.base/hbreak2.exp: hardware breakpoint insertion +PASS: gdb.base/hbreak2.exp: hardware breakpoint function +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: use `list' to establish default source file +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line if conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint at start of multi line while conditional +PASS: gdb.base/hbreak2.exp: hardware breakpoint info +PASS: gdb.base/hbreak2.exp: hardware breakpoint function (2) +PASS: gdb.base/hbreak2.exp: run until function breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number (2) +PASS: gdb.base/hbreak2.exp: run until breakpoint set at a line number +PASS: gdb.base/hbreak2.exp: hardware breakpoint function in file (2) +PASS: gdb.base/hbreak2.exp: run until file:function(6) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(5) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(4) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(3) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(2) breakpoint +PASS: gdb.base/hbreak2.exp: run until file:function(1) breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint quoted function (2) +PASS: gdb.base/hbreak2.exp: run until quoted breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint line number in file (2) +PASS: gdb.base/hbreak2.exp: run until file:linenum breakpoint +PASS: gdb.base/hbreak2.exp: hardware breakpoint offset +1 +PASS: gdb.base/hbreak2.exp: step onto hardware breakpoint +PASS: gdb.base/hbreak2.exp: setting hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: continue to hardware breakpoint at } +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint function in file +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #1 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint line number in file #2 +PASS: gdb.base/hbreak2.exp: temporary hardware breakpoint info +PASS: gdb.base/hbreak2.exp: set breakpoint pending off +PASS: gdb.base/hbreak2.exp: hardware break on non-existent source line +PASS: gdb.base/hbreak2.exp: until bp_location1 +PASS: gdb.base/hbreak2.exp: hardware break on default location +PASS: gdb.base/hbreak2.exp: set to-be-silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: set silent break bp_location1 +PASS: gdb.base/hbreak2.exp: info silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: hit silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: stopped for silent hardware break bp_location1 +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on non-existent thread disallowed +PASS: gdb.base/hbreak2.exp: thread-specific hardware breakpoint on bogus thread ID disallowed +PASS: gdb.base/hbreak2.exp: hardware breakpoint with trailing garbage disallowed +PASS: gdb.base/hbreak2.exp: step over hardware breakpoint +PASS: gdb.base/hbreak2.exp: clear line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via convenience variable +PASS: gdb.base/hbreak2.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/hbreak2.exp: set hardware breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/hbreak2.exp: set hardware breakpoint on to-be-called function +PASS: gdb.base/hbreak2.exp: hit hardware breakpoint on called function +PASS: gdb.base/hbreak2.exp: backtrace while in called function +PASS: gdb.base/hbreak2.exp: finish from called function +PASS: gdb.base/hbreak2.exp: hardware break at factorial +PASS: gdb.base/hbreak2.exp: kill program +PASS: gdb.base/hbreak2.exp: run to factorial(6) +PASS: gdb.base/hbreak2.exp: continue to factorial(5) +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5) +PASS: gdb.base/hbreak2.exp: next to recursive call +PASS: gdb.base/hbreak2.exp: next over recursive call +PASS: gdb.base/hbreak2.exp: backtrace from factorial(5.1) +PASS: gdb.base/hbreak2.exp: continue until exit at recursive next test +PASS: gdb.base/hbreak2.exp: hardware breakpoint function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware function breakpoint, optimized file (code motion) +PASS: gdb.base/hbreak2.exp: hardware breakpoint small function, optimized file +PASS: gdb.base/hbreak2.exp: run until hardware breakpoint set at small function, optimized file +Running ./gdb.base/hbreak.exp ... +Running ./gdb.base/help.exp ... +PASS: gdb.base/help.exp: disable pagination +PASS: gdb.base/help.exp: help aliases +PASS: gdb.base/help.exp: help breakpoints +PASS: gdb.base/help.exp: help data +PASS: gdb.base/help.exp: help files +PASS: gdb.base/help.exp: help internals +PASS: gdb.base/help.exp: help obscure +PASS: gdb.base/help.exp: help running +PASS: gdb.base/help.exp: help stack +PASS: gdb.base/help.exp: help status +PASS: gdb.base/help.exp: help support +PASS: gdb.base/help.exp: help tracepoints +PASS: gdb.base/help.exp: help user-defined +PASS: gdb.base/help.exp: help breakpoint "b" abbreviation +PASS: gdb.base/help.exp: help breakpoint "br" abbreviation +PASS: gdb.base/help.exp: help breakpoint "bre" abbreviation +PASS: gdb.base/help.exp: help breakpoint "brea" abbreviation +PASS: gdb.base/help.exp: help breakpoint "break" abbreviation +PASS: gdb.base/help.exp: help backtrace "bt" abbreviation +PASS: gdb.base/help.exp: help backtrace +PASS: gdb.base/help.exp: help commands +PASS: gdb.base/help.exp: help delete "d" abbreviation +PASS: gdb.base/help.exp: help delete +PASS: gdb.base/help.exp: help help "h" abbreviation +PASS: gdb.base/help.exp: help help +PASS: gdb.base/help.exp: help show copying +PASS: gdb.base/help.exp: help show warranty +PASS: gdb.base/help.exp: help show commands +PASS: gdb.base/help.exp: help show confirm +PASS: gdb.base/help.exp: help info bogus-gdb-command +PASS: gdb.base/help.exp: help gotcha +PASS: gdb.base/help.exp: apropos \(print[^ bsiedf\".-]\) +PASS: gdb.base/help.exp: apropos handle signal +PASS: gdb.base/help.exp: apropos apropos +Running ./gdb.base/hook-stop-continue.exp ... +PASS: gdb.base/hook-stop-continue.exp: breakpoint line number +PASS: gdb.base/hook-stop-continue.exp: print $do_continue = 1 +PASS: gdb.base/hook-stop-continue.exp: define hook-stop command +PASS: gdb.base/hook-stop-continue.exp: next triggering hook-stop +PASS: gdb.base/hook-stop-continue.exp: next no hook-stop +Running ./gdb.base/hook-stop-frame.exp ... +PASS: gdb.base/hook-stop-frame.exp: breakpoint line number +PASS: gdb.base/hook-stop-frame.exp: define hook-stop command +PASS: gdb.base/hook-stop-frame.exp: hook-stop runs before frame print +Running ./gdb.base/huge.exp ... +PASS: gdb.base/huge.exp: print a very large data object +Running ./gdb.base/ifelse.exp ... +PASS: gdb.base/ifelse.exp: if 1 with empty body +PASS: gdb.base/ifelse.exp: if 0 with empty body +PASS: gdb.base/ifelse.exp: if true else false #1 +PASS: gdb.base/ifelse.exp: if 1 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #2 +PASS: gdb.base/ifelse.exp: if 0 .. else with empty body +PASS: gdb.base/ifelse.exp: if true else false #3 +PASS: gdb.base/ifelse.exp: create define with empty else +PASS: gdb.base/ifelse.exp: call original define +PASS: gdb.base/ifelse.exp: replace define with if .. else with empty body +PASS: gdb.base/ifelse.exp: call replacement define +Running ./gdb.base/included.exp ... +PASS: gdb.base/included.exp: set listsize 1 +PASS: gdb.base/included.exp: list main +PASS: gdb.base/included.exp: list integer +PASS: gdb.base/included.exp: ptype integer +PASS: gdb.base/included.exp: info variables integer +Running ./gdb.base/inferior-died.exp ... +UNSUPPORTED: gdb.base/inferior-died.exp: inferior-died.exp +Running ./gdb.base/infnan.exp ... +PASS: gdb.base/infnan.exp: print a +PASS: gdb.base/infnan.exp: print b +Running ./gdb.base/info-fun.exp ... +Running ./gdb.base/infoline.exp ... +PASS: gdb.base/infoline.exp: info line infoline.c:18 +Running ./gdb.base/info-macros.exp ... +FAIL: gdb.base/info-macros.exp: info macro -- -all +FAIL: gdb.base/info-macros.exp: info macro -- -all +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -all -- +PASS: gdb.base/info-macros.exp: info macro -- +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: 'info macro -- ' +PASS: gdb.base/info-macros.exp: info macro -invalid-option 1 +PASS: gdb.base/info-macros.exp: info macro -invalid-option +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +PASS: gdb.base/info-macros.exp: info macro -invalid-option FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro -- FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro FOO +FAIL: gdb.base/info-macros.exp: info macro -a FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -all -- FOO 1 +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macro -a -- FOO +FAIL: gdb.base/info-macros.exp: info macros 2 +FAIL: gdb.base/info-macros.exp: info macros 3 +FAIL: gdb.base/info-macros.exp: info macros 4 +FAIL: gdb.base/info-macros.exp: info macros *$pc +FAIL: gdb.base/info-macros.exp: info macros +FAIL: gdb.base/info-macros.exp: info macros 6 +FAIL: gdb.base/info-macros.exp: info macros 7 +KFAIL: gdb.base/info-macros.exp: info macros info-macros.c:42 (PRMS: gdb/NNNN) +Running ./gdb.base/info-os.exp ... +PASS: gdb.base/info-os.exp: get inferior process ID +PASS: gdb.base/info-os.exp: continue to breakpoint: Set breakpoint here +PASS: gdb.base/info-os.exp: get shared memory key +PASS: gdb.base/info-os.exp: get shared memory ID +PASS: gdb.base/info-os.exp: get semaphore key +PASS: gdb.base/info-os.exp: get semaphore ID +PASS: gdb.base/info-os.exp: get message queue key +PASS: gdb.base/info-os.exp: get message queue ID +PASS: gdb.base/info-os.exp: get socket port number +PASS: gdb.base/info-os.exp: get process list +PASS: gdb.base/info-os.exp: get process groups +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get threads +PASS: gdb.base/info-os.exp: get file descriptors +PASS: gdb.base/info-os.exp: get internet-domain sockets +PASS: gdb.base/info-os.exp: get shared-memory regions +PASS: gdb.base/info-os.exp: get semaphores +PASS: gdb.base/info-os.exp: get message queues +PASS: gdb.base/info-os.exp: continue +Running ./gdb.base/info-proc.exp ... +PASS: gdb.base/info-proc.exp: help info proc +PASS: gdb.base/info-proc.exp: info proc without a process +PASS: gdb.base/info-proc.exp: info proc with process +PASS: gdb.base/info-proc.exp: info proc mapping +PASS: gdb.base/info-proc.exp: save a core file +FAIL: gdb.base/info-proc.exp: core break.gcore +FAIL: gdb.base/info-proc.exp: info proc mapping with core file +Running ./gdb.base/info-target.exp ... +PASS: gdb.base/info-target.exp: info target +Running ./gdb.base/interact.exp ... +PASS: gdb.base/interact.exp: set interactive-mode auto +PASS: gdb.base/interact.exp: source script with interactive-mode auto +PASS: gdb.base/interact.exp: sanity check with interactive-mode auto +PASS: gdb.base/interact.exp: show interactive-mode (auto) +PASS: gdb.base/interact.exp: set interactive-mode on +PASS: gdb.base/interact.exp: source script with interactive-mode on +PASS: gdb.base/interact.exp: sanity check with interactive-mode on +PASS: gdb.base/interact.exp: show interactive-mode (on) +PASS: gdb.base/interact.exp: set interactive-mode off +PASS: gdb.base/interact.exp: source script with interactive-mode off +PASS: gdb.base/interact.exp: sanity check with interactive-mode off +PASS: gdb.base/interact.exp: show interactive-mode (off) +Running ./gdb.base/interp.exp ... +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec console "show version" +PASS: gdb.base/interp.exp: interpreter-exec mi "-var-update *" +PASS: gdb.base/interp.exp: interpreter-exec mi "-stack-info-frame" +PASS: gdb.base/interp.exp: interpreter-exec mi1 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi2 "-break-insert main" +PASS: gdb.base/interp.exp: interpreter-exec mi3 "-break-insert main" +PASS: gdb.base/interp.exp: can list sources +Running ./gdb.base/interrupt.exp ... +Running ./gdb.base/jit.exp ... +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: one_jit_test-2: set var argc = 2 +PASS: gdb.base/jit.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: one_jit_test-2: set var count = 2 +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit.exp: PIE: one_jit_test-1: info function jit_function +Running ./gdb.base/jit-simple.exp ... +PASS: gdb.base/jit-simple.exp: blah 1 +PASS: gdb.base/jit-simple.exp: recompile jit-simple.c +PASS: gdb.base/jit-simple.exp: blah 1 +Running ./gdb.base/jit-so.exp ... +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here before-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var jit_libname = "jit-main.so" +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here after-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 0 +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var argc = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit-so.exp: one_jit_test-1: set var count = 1 +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 1 +PASS: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-1: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-1: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here before-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var jit_libname = "jit-main.so" +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here after-dlopen +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 0 +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var argc = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var libname = "SHLIBDIR/jit-solib.so" +PASS: gdb.base/jit-so.exp: one_jit_test-2: set var count = 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 1 +PASS: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +PASS: gdb.base/jit-so.exp: one_jit_test-2: continue to breakpoint: break here 2 +PASS: gdb.base/jit-so.exp: one_jit_test-2: info function jit_function +Running ./gdb.base/jump.exp ... +PASS: gdb.base/jump.exp: break before jump to non-call +PASS: gdb.base/jump.exp: jump to non-call +PASS: gdb.base/jump.exp: break before jump to call +PASS: gdb.base/jump.exp: jump to call +PASS: gdb.base/jump.exp: disable breakpoint on call +PASS: gdb.base/jump.exp: jump to call with disabled breakpoint +PASS: gdb.base/jump.exp: jump without argument disallowed +PASS: gdb.base/jump.exp: jump with trailing argument junk +PASS: gdb.base/jump.exp: aborted jump out of current function +PASS: gdb.base/jump.exp: jump out of current function +Running ./gdb.base/kill-after-signal.exp ... +PASS: gdb.base/kill-after-signal.exp: handle SIGUSR1 stop print pass +PASS: gdb.base/kill-after-signal.exp: continue +PASS: gdb.base/kill-after-signal.exp: stepi +PASS: gdb.base/kill-after-signal.exp: kill +Running ./gdb.base/label.exp ... +Running ./gdb.base/langs.exp ... +PASS: gdb.base/langs.exp: break on nonexistent function in langs.exp +PASS: gdb.base/langs.exp: show language at csub in langs.exp +PASS: gdb.base/langs.exp: backtrace in langs.exp +PASS: gdb.base/langs.exp: up to foo in langs.exp +PASS: gdb.base/langs.exp: show language at foo in langs.exp +PASS: gdb.base/langs.exp: up to cppsub_ in langs.exp +PASS: gdb.base/langs.exp: show language at cppsub_ in langs.exp +PASS: gdb.base/langs.exp: up to fsub in langs.exp +PASS: gdb.base/langs.exp: show language at fsub in langs.exp +PASS: gdb.base/langs.exp: up to langs0__2do in langs.exp +PASS: gdb.base/langs.exp: show language at langs0__2do in langs.exp +PASS: gdb.base/langs.exp: up to main in langs.exp +PASS: gdb.base/langs.exp: show language at main in langs.exp +PASS: gdb.base/langs.exp: continue until exit at langs.exp +PASS: gdb.base/langs.exp: set lang to minimal +PASS: gdb.base/langs.exp: print parameter value +Running ./gdb.base/ldbl_e308.exp ... +PASS: gdb.base/ldbl_e308.exp: set variable ldbl_308 = 1.6e+308l +PASS: gdb.base/ldbl_e308.exp: print ldbl_308 +Running ./gdb.base/lineinc.exp ... +PASS: gdb.base/lineinc.exp: tolerate macro info with multiple #inclusions per line +Running ./gdb.base/linespecs.exp ... +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list c:/foo/bar/baz.c +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c:1 +PASS: gdb.base/linespecs.exp: list fooc:/foo/bar/baz.c +Running ./gdb.base/list.exp ... +PASS: gdb.base/list.exp: set width 0 +PASS: gdb.base/list.exp: show default list size +PASS: gdb.base/list.exp: list default lines around main +PASS: gdb.base/list.exp: setting listsize to 1 #1 +PASS: gdb.base/list.exp: show listsize 1 #1 +PASS: gdb.base/list.exp: list line 1 with listsize 1 +PASS: gdb.base/list.exp: list line 2 with listsize 1 +PASS: gdb.base/list.exp: setting listsize to 2 #2 +PASS: gdb.base/list.exp: show listsize 2 #2 +PASS: gdb.base/list.exp: list line 1 with listsize 2 +PASS: gdb.base/list.exp: list line 2 with listsize 2 +PASS: gdb.base/list.exp: list line 3 with listsize 2 +PASS: gdb.base/list.exp: setting listsize to 3 #3 +PASS: gdb.base/list.exp: show listsize 3 #3 +PASS: gdb.base/list.exp: list line 1 with listsize 3 +PASS: gdb.base/list.exp: list line 2 with listsize 3 +PASS: gdb.base/list.exp: list line 3 with listsize 3 +PASS: gdb.base/list.exp: setting listsize to 4 #4 +PASS: gdb.base/list.exp: show listsize 4 #4 +PASS: gdb.base/list.exp: list line 1 with listsize 4 +PASS: gdb.base/list.exp: list line 2 with listsize 4 +PASS: gdb.base/list.exp: list line 3 with listsize 4 +PASS: gdb.base/list.exp: list line 4 with listsize 4 +PASS: gdb.base/list.exp: setting listsize to 100 #5 +PASS: gdb.base/list.exp: show listsize 100 #5 +PASS: gdb.base/list.exp: list line 1 with listsize 100 +PASS: gdb.base/list.exp: list line 10 with listsize 100 +PASS: gdb.base/list.exp: setting listsize to 0 #6 +PASS: gdb.base/list.exp: show listsize unlimited #6 +PASS: gdb.base/list.exp: list line 1 with unlimited listsize +PASS: gdb.base/list.exp: setting listsize to 10 #7 +PASS: gdb.base/list.exp: show listsize 10 #7 +PASS: gdb.base/list.exp: list line 1 in include file +PASS: gdb.base/list.exp: list message for lines past EOF +PASS: gdb.base/list.exp: list filename:number (4 tests) +PASS: gdb.base/list.exp: list function in source file 1 +PASS: gdb.base/list.exp: list function in source file 2 +PASS: gdb.base/list.exp: list function in include file +PASS: gdb.base/list.exp: successive list commands to page forward (4 tests) +PASS: gdb.base/list.exp: 4 successive "list -" commands to page backwards +PASS: gdb.base/list.exp: repeat list commands to page forward using 'return' (4 tests) +PASS: gdb.base/list.exp: list range; filename:line1,filename:line2 +PASS: gdb.base/list.exp: list range; line1,line2 +PASS: gdb.base/list.exp: list range; upper bound past EOF +PASS: gdb.base/list.exp: list range; both bounds past EOF +PASS: gdb.base/list.exp: list range, must be same files +PASS: gdb.base/list.exp: list filename:function (5 tests) +PASS: gdb.base/list.exp: list 'list0.c:main' +XFAIL: gdb.base/list.exp: list filename:function; wrong filename rejected +PASS: gdb.base/list.exp: list filename:function; nonexistant file +PASS: gdb.base/list.exp: list filename:function; nonexistant function +PASS: gdb.base/list.exp: set listsize 4 +PASS: gdb.base/list.exp: list long_line +PASS: gdb.base/list.exp: search 4321 +PASS: gdb.base/list.exp: search 6789 +PASS: gdb.base/list.exp: search extremely long line (> 5000 chars) +PASS: gdb.base/list.exp: set listsize 2 +PASS: gdb.base/list.exp: list 1 +PASS: gdb.base/list.exp: list ,5 +Running ./gdb.base/logical.exp ... +PASS: gdb.base/logical.exp: evaluate x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x; variables x = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !!x; variables x = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 0, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 0, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x && y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x && !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || !y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x < y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x <= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x == y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x != y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y; variables x = 1, y = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y; variables x = 1, y = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 0, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 0, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 0, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 0, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 0; expecting 0 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 0; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x && y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || y || z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate x || !y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && z; variables x = 1, y = 1, z = 1; expecting 1 +PASS: gdb.base/logical.exp: evaluate !x || y && !z; variables x = 1, y = 1, z = 1; expecting 0 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 3, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 3, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 1, y = 2, w = 1, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 1, y = 2, w = 1, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate x > y || w == z; variables x = 2, y = 2, w = 2, z = 3; expecting 0 +PASS: gdb.base/logical.exp: evaluate x >= y && w != z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +PASS: gdb.base/logical.exp: evaluate ! x > y || w + z; variables x = 2, y = 2, w = 2, z = 3; expecting 1 +Running ./gdb.base/longest-types.exp ... +PASS: gdb.base/longest-types.exp: print &f->buf +Running ./gdb.base/longjmp.exp ... +PASS: gdb.base/longjmp.exp: breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 1 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_1 +PASS: gdb.base/longjmp.exp: next over setjmp (1) +PASS: gdb.base/longjmp.exp: next to longjmp (1) +FAIL: gdb.base/longjmp.exp: next over longjmp(1) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 2 start +PASS: gdb.base/longjmp.exp: breakpoint at miss_step_2 +PASS: gdb.base/longjmp.exp: next over setjmp (2) +FAIL: gdb.base/longjmp.exp: next over call_longjmp (2) +PASS: gdb.base/longjmp.exp: breakpoint at pattern 3 start +PASS: gdb.base/longjmp.exp: continue to breakpoint at pattern 3 start +PASS: gdb.base/longjmp.exp: next over patt3 +Running ./gdb.base/long_long.exp ... +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (char)" (1) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (short)" (2) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (int)" (4) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long long)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (void *)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (double)" (8) +PASS: gdb.base/long_long.exp: get integer valueof "sizeof (long double)" (16) +PASS: gdb.base/long_long.exp: continue to breakpoint: Stop here and look +PASS: gdb.base/long_long.exp: hex print p/x +PASS: gdb.base/long_long.exp: decimal print p/x +PASS: gdb.base/long_long.exp: default print val.dec +PASS: gdb.base/long_long.exp: default print val.bin +PASS: gdb.base/long_long.exp: default print val.oct +PASS: gdb.base/long_long.exp: default print hex +PASS: gdb.base/long_long.exp: decimal print p/u +PASS: gdb.base/long_long.exp: binary print +PASS: gdb.base/long_long.exp: octal print +PASS: gdb.base/long_long.exp: print +ve long long +PASS: gdb.base/long_long.exp: decimal print p/d +PASS: gdb.base/long_long.exp: p/d val.oct +PASS: gdb.base/long_long.exp: p/u val.oct +PASS: gdb.base/long_long.exp: p/o val.oct +PASS: gdb.base/long_long.exp: p/t val.oct +PASS: gdb.base/long_long.exp: p/a val.oct +PASS: gdb.base/long_long.exp: p/c val.oct +PASS: gdb.base/long_long.exp: p/f val.oct +PASS: gdb.base/long_long.exp: p/x *(char *)c +PASS: gdb.base/long_long.exp: p/d *(char *)c +PASS: gdb.base/long_long.exp: p/u *(char *)c +PASS: gdb.base/long_long.exp: p/o *(char *)c +PASS: gdb.base/long_long.exp: p/t *(char *)c +PASS: gdb.base/long_long.exp: p/a *(char *)c +PASS: gdb.base/long_long.exp: p/f *(char *)c +PASS: gdb.base/long_long.exp: p/c *(char *)c +PASS: gdb.base/long_long.exp: p/x *(short *)s +PASS: gdb.base/long_long.exp: p/d *(short *)s +PASS: gdb.base/long_long.exp: p/u *(short *)s +PASS: gdb.base/long_long.exp: p/o *(short *)s +PASS: gdb.base/long_long.exp: p/t *(short *)s +PASS: gdb.base/long_long.exp: p/a *(short *)s +PASS: gdb.base/long_long.exp: p/f *(short *)s +PASS: gdb.base/long_long.exp: p/c *(short *)s +PASS: gdb.base/long_long.exp: p/x *(int *)i +PASS: gdb.base/long_long.exp: p/d *(int *)i +PASS: gdb.base/long_long.exp: p/u *(int *)i +PASS: gdb.base/long_long.exp: p/o *(int *)i +PASS: gdb.base/long_long.exp: p/t *(int *)i +PASS: gdb.base/long_long.exp: p/a *(int *)i +PASS: gdb.base/long_long.exp: p/f *(int *)i +PASS: gdb.base/long_long.exp: p/c *(int *)i +PASS: gdb.base/long_long.exp: p/x *(long *)l +PASS: gdb.base/long_long.exp: p/d *(long *)l +PASS: gdb.base/long_long.exp: p/u *(long *)l +PASS: gdb.base/long_long.exp: p/o *(long *)l +PASS: gdb.base/long_long.exp: p/t *(long *)l +PASS: gdb.base/long_long.exp: p/a *(long *)l +PASS: gdb.base/long_long.exp: p/f *(long *)l +PASS: gdb.base/long_long.exp: p/c *(long *)l +PASS: gdb.base/long_long.exp: p/x *(long long *)ll +PASS: gdb.base/long_long.exp: p/d *(long long *)ll +PASS: gdb.base/long_long.exp: p/u *(long long *)ll +PASS: gdb.base/long_long.exp: p/o *(long long *)ll +PASS: gdb.base/long_long.exp: p/t *(long long *)ll +PASS: gdb.base/long_long.exp: p/a *(long long *)ll +PASS: gdb.base/long_long.exp: p/f *(long long *)ll +PASS: gdb.base/long_long.exp: p/c *(long long *)ll +PASS: gdb.base/long_long.exp: set examine size to w +PASS: gdb.base/long_long.exp: x/x w +PASS: gdb.base/long_long.exp: x/d w +PASS: gdb.base/long_long.exp: x/u w +PASS: gdb.base/long_long.exp: x/o w +PASS: gdb.base/long_long.exp: x/t w +PASS: gdb.base/long_long.exp: x/a +PASS: gdb.base/long_long.exp: x/c b +PASS: gdb.base/long_long.exp: x/f &val.oct +PASS: gdb.base/long_long.exp: set examine size to g +PASS: gdb.base/long_long.exp: x/2x g +PASS: gdb.base/long_long.exp: x/2d g +PASS: gdb.base/long_long.exp: x/2u g +PASS: gdb.base/long_long.exp: x/2o g +PASS: gdb.base/long_long.exp: x/2t g +PASS: gdb.base/long_long.exp: x/2a +PASS: gdb.base/long_long.exp: x/2c b +PASS: gdb.base/long_long.exp: x/2f &val.oct +PASS: gdb.base/long_long.exp: x/2bx b +PASS: gdb.base/long_long.exp: x/2bd b +PASS: gdb.base/long_long.exp: x/2bu b +PASS: gdb.base/long_long.exp: x/2bo b +PASS: gdb.base/long_long.exp: x/2bt b +PASS: gdb.base/long_long.exp: x/2ba b +PASS: gdb.base/long_long.exp: x/2bc b +PASS: gdb.base/long_long.exp: x/2bf b +PASS: gdb.base/long_long.exp: x/2hx h +PASS: gdb.base/long_long.exp: x/2hd h +PASS: gdb.base/long_long.exp: x/2hu h +PASS: gdb.base/long_long.exp: x/2ho h +PASS: gdb.base/long_long.exp: x/2ht h +PASS: gdb.base/long_long.exp: x/2ha h +PASS: gdb.base/long_long.exp: x/2hc h +PASS: gdb.base/long_long.exp: x/2hf h +PASS: gdb.base/long_long.exp: x/2wx w +PASS: gdb.base/long_long.exp: x/2wd w +PASS: gdb.base/long_long.exp: x/2wu w +PASS: gdb.base/long_long.exp: x/2wo w +PASS: gdb.base/long_long.exp: x/2wt w +PASS: gdb.base/long_long.exp: x/2wa w +PASS: gdb.base/long_long.exp: x/2wc w +PASS: gdb.base/long_long.exp: x/2wf w +PASS: gdb.base/long_long.exp: x/2gx g +PASS: gdb.base/long_long.exp: x/2gd g +PASS: gdb.base/long_long.exp: x/2gu g +PASS: gdb.base/long_long.exp: x/2go g +PASS: gdb.base/long_long.exp: x/2gt g +PASS: gdb.base/long_long.exp: x/2ga g +PASS: gdb.base/long_long.exp: x/2gc g +PASS: gdb.base/long_long.exp: x/2gf g +Running ./gdb.base/macscp.exp ... +PASS: gdb.base/macscp.exp: list main for support check +UNSUPPORTED: gdb.base/macscp.exp: Skipping test because debug information does not include macro information. +Running ./gdb.base/maint.exp ... +PASS: gdb.base/maint.exp: set height 0 +PASS: gdb.base/maint.exp: maint print registers +PASS: gdb.base/maint.exp: maint check-symtabs +PASS: gdb.base/maint.exp: maint space +PASS: gdb.base/maint.exp: maint space 1 +PASS: gdb.base/maint.exp: maint time +PASS: gdb.base/maint.exp: maint time 1 +PASS: gdb.base/maint.exp: maint time 0 +PASS: gdb.base/maint.exp: maint space 0 +PASS: gdb.base/maint.exp: maint demangle +PASS: gdb.base/maint.exp: maint demangle main +PASS: gdb.base/maint.exp: maint print statistics +PASS: gdb.base/maint.exp: maint print dummy-frames +PASS: gdb.base/maint.exp: maint print objfiles: header +PASS: gdb.base/maint.exp: maint print objfiles: psymtabs +PASS: gdb.base/maint.exp: maint print objfiles: symtabs +PASS: gdb.base/maint.exp: maint print psymbols w/o args +PASS: gdb.base/maint.exp: maint print psymbols 1 +PASS: gdb.base/maint.exp: shell rm -f psymbols_output +PASS: gdb.base/maint.exp: maint print msymbols w/o args +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output +PASS: gdb.base/maint.exp: cd to objdir +PASS: gdb.base/maint.exp: maint print msymbols +PASS: gdb.base/maint.exp: shell rm -f msymbols_output2 +PASS: gdb.base/maint.exp: cd to mydir +PASS: gdb.base/maint.exp: maint print symbols w/o args +PASS: gdb.base/maint.exp: maint print symbols +PASS: gdb.base/maint.exp: shell rm -f symbols_output +PASS: gdb.base/maint.exp: maint print type +PASS: gdb.base/maint.exp: maint info sections +PASS: gdb.base/maint.exp: maint info sections .text +PASS: gdb.base/maint.exp: maint info sections CODE +PASS: gdb.base/maint.exp: maint info sections DATA +PASS: gdb.base/maint.exp: maint info breakpoints +PASS: gdb.base/maint.exp: maint print w/o args +PASS: gdb.base/maint.exp: maint info w/o args +PASS: gdb.base/maint.exp: maint w/o args +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: help maint check-symtabs +PASS: gdb.base/maint.exp: help maint space +PASS: gdb.base/maint.exp: help maint time +PASS: gdb.base/maint.exp: help maint demangle +PASS: gdb.base/maint.exp: help maint dump-me +PASS: gdb.base/maint.exp: help maint internal-error +PASS: gdb.base/maint.exp: help maint internal-warning +PASS: gdb.base/maint.exp: help maint print statistics +PASS: gdb.base/maint.exp: help maint print dummy-frames +PASS: gdb.base/maint.exp: help maint print objfiles +PASS: gdb.base/maint.exp: help maint print psymbols +PASS: gdb.base/maint.exp: help maint print msymbols +PASS: gdb.base/maint.exp: help maint print symbols +PASS: gdb.base/maint.exp: help maint print type +PASS: gdb.base/maint.exp: help maint info sections +PASS: gdb.base/maint.exp: help maint info breakpoints +PASS: gdb.base/maint.exp: help maint info +PASS: gdb.base/maint.exp: help maint print +PASS: gdb.base/maint.exp: help maint +PASS: gdb.base/maint.exp: maint dump-me +PASS: gdb.base/maint.exp: maint internal-error +PASS: gdb.base/maint.exp: internal-error resync +Running ./gdb.base/memattr.exp ... +PASS: gdb.base/memattr.exp: create mem region 1 +PASS: gdb.base/memattr.exp: create mem region 2 +PASS: gdb.base/memattr.exp: create mem region 3 +PASS: gdb.base/memattr.exp: create mem region 4 +PASS: gdb.base/memattr.exp: create mem region 5 +PASS: gdb.base/memattr.exp: info mem (1) +PASS: gdb.base/memattr.exp: mem1 cannot be read +PASS: gdb.base/memattr.exp: mem1 can be written +PASS: gdb.base/memattr.exp: mem2 cannot be written +PASS: gdb.base/memattr.exp: mem2 can be read +PASS: gdb.base/memattr.exp: disable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was disabled +PASS: gdb.base/memattr.exp: enable mem 1 +PASS: gdb.base/memattr.exp: mem 1 was enabled +PASS: gdb.base/memattr.exp: disable mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were disabled +PASS: gdb.base/memattr.exp: enable mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were enabled +PASS: gdb.base/memattr.exp: disable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were disabled +PASS: gdb.base/memattr.exp: enable mem +PASS: gdb.base/memattr.exp: mem 1 to 5 were enabled +PASS: gdb.base/memattr.exp: disable non-existant regions +PASS: gdb.base/memattr.exp: delete mem 1 +PASS: gdb.base/memattr.exp: mem 1 was deleted +PASS: gdb.base/memattr.exp: delete mem 2 4 +PASS: gdb.base/memattr.exp: mem 2 and 4 were deleted +PASS: gdb.base/memattr.exp: delete mem 2-4 +PASS: gdb.base/memattr.exp: mem 2-4 were deleted +PASS: gdb.base/memattr.exp: delete non-existant region +PASS: gdb.base/memattr.exp: mem 0x30 0x60 ro +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x40: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x50 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x60: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x70: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x60 0x70: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x60: 0x80 0x0: no-overlap +PASS: gdb.base/memattr.exp: mem 0x30 0x0 ro +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x50: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x30 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x40 0x0: overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x20 0x30: no-overlap +PASS: gdb.base/memattr.exp: 0x30 0x0: 0x00 0x10: no-overlap +Running ./gdb.base/mips_pro.exp ... +PASS: gdb.base/mips_pro.exp: backtrace +Running ./gdb.base/miscexprs.exp ... +PASS: gdb.base/miscexprs.exp: continue to marker1 +PASS: gdb.base/miscexprs.exp: up from marker1 +PASS: gdb.base/miscexprs.exp: print value of &ibig.i[0] +PASS: gdb.base/miscexprs.exp: print value of &cbig.c[0] +PASS: gdb.base/miscexprs.exp: print value of &fbig.f[0] +PASS: gdb.base/miscexprs.exp: print value of &dbig.d[0] +PASS: gdb.base/miscexprs.exp: print value of &sbig.s[0] +PASS: gdb.base/miscexprs.exp: print value of &lbig.l[0] +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] | 1 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] & 127 +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !ibig.i[100] +PASS: gdb.base/miscexprs.exp: print value of !sbig.s[90] * 10 +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] * sbig.s[90] +PASS: gdb.base/miscexprs.exp: print value of fbig.f[100] * dbig.d[202] +PASS: gdb.base/miscexprs.exp: print value of !(sbig.s[90] * 2) +PASS: gdb.base/miscexprs.exp: print value of sizeof sbig +PASS: gdb.base/miscexprs.exp: print value of sizeof cbig +PASS: gdb.base/miscexprs.exp: print value of sizeof lbig / sizeof long +PASS: gdb.base/miscexprs.exp: print value of ibig.i[100] << 2 +PASS: gdb.base/miscexprs.exp: print value of sbig.s[90] >> 4 +PASS: gdb.base/miscexprs.exp: print value of lbig.l[333] >> 6 +Running ./gdb.base/morestack.exp ... +PASS: gdb.base/morestack.exp: continue +PASS: gdb.base/morestack.exp: up 3000 +Running ./gdb.base/moribund-step.exp ... +PASS: gdb.base/moribund-step.exp: set non-stop on +Running ./gdb.base/multi-forks.exp ... +Running ./gdb.base/nextoverexit.exp ... +PASS: gdb.base/nextoverexit.exp: next over exit +Running ./gdb.base/nodebug.exp ... +PASS: gdb.base/nodebug.exp: p top +PASS: gdb.base/nodebug.exp: whatis top +PASS: gdb.base/nodebug.exp: ptype top +PASS: gdb.base/nodebug.exp: p middle +PASS: gdb.base/nodebug.exp: whatis middle +PASS: gdb.base/nodebug.exp: ptype middle +PASS: gdb.base/nodebug.exp: p dataglobal +PASS: gdb.base/nodebug.exp: whatis dataglobal +PASS: gdb.base/nodebug.exp: ptype dataglobal +PASS: gdb.base/nodebug.exp: p datalocal +PASS: gdb.base/nodebug.exp: whatis datalocal +PASS: gdb.base/nodebug.exp: ptype datalocal +PASS: gdb.base/nodebug.exp: p bssglobal +PASS: gdb.base/nodebug.exp: whatis bssglobal +PASS: gdb.base/nodebug.exp: ptype bssglobal +PASS: gdb.base/nodebug.exp: p bsslocal +PASS: gdb.base/nodebug.exp: whatis bsslocal +PASS: gdb.base/nodebug.exp: ptype bsslocal +PASS: gdb.base/nodebug.exp: backtrace from inner in nodebug.exp +PASS: gdb.base/nodebug.exp: p/c array_index("abcdef",2) +PASS: gdb.base/nodebug.exp: backtrace from middle in nodebug.exp +Running ./gdb.base/nofield.exp ... +PASS: gdb.base/nofield.exp: ptype struct not_empty +PASS: gdb.base/nofield.exp: ptype struct empty +PASS: gdb.base/nofield.exp: ptype union empty_union +Running ./gdb.base/nostdlib.exp ... +UNTESTED: gdb.base/nostdlib.exp: nostdlib.exp +Running ./gdb.base/opaque.exp ... +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (statically) +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (statically) +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 1 +PASS: gdb.base/opaque.exp: whatis on opaque struct pointer (dynamically) 1 +PASS: gdb.base/opaque.exp: ptype on opaque struct pointer (dynamically) 2 +PASS: gdb.base/opaque.exp: whatis on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct instance (dynamically) 2 +PASS: gdb.base/opaque.exp: ptype on opaque struct tagname (dynamically) 2 +Running ./gdb.base/overlays.exp ... +Running ./gdb.base/page.exp ... +PASS: gdb.base/page.exp: set pagination off +PASS: gdb.base/page.exp: pagination is off +PASS: gdb.base/page.exp: unpaged help +PASS: gdb.base/page.exp: set pagination on +PASS: gdb.base/page.exp: pagination is on +PASS: gdb.base/page.exp: set height 10 +PASS: gdb.base/page.exp: paged help +PASS: gdb.base/page.exp: q +Running ./gdb.base/pc-fp.exp ... +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$pc" +PASS: gdb.base/pc-fp.exp: get hexadecimal valueof "$fp" +PASS: gdb.base/pc-fp.exp: display/i $pc +PASS: gdb.base/pc-fp.exp: display/w $fp +PASS: gdb.base/pc-fp.exp: info register $pc +PASS: gdb.base/pc-fp.exp: info register $fp +PASS: gdb.base/pc-fp.exp: info register pc fp +Running ./gdb.base/pending.exp ... +PASS: gdb.base/pending.exp: set pending breakpoint (without symbols) +PASS: gdb.base/pending.exp: complete condition +PASS: gdb.base/pending.exp: single pending breakpoint info (without symbols) +PASS: gdb.base/pending.exp: run to resolved breakpoint 1 (without symbols) +PASS: gdb.base/pending.exp: set pending breakpoint +PASS: gdb.base/pending.exp: single pending breakpoint info +PASS: gdb.base/pending.exp: breakpoint function +PASS: gdb.base/pending.exp: pending plus real breakpoint info +PASS: gdb.base/pending.exp: Don't set pending breakpoint +PASS: gdb.base/pending.exp: condition 1 k == 1 +PASS: gdb.base/pending.exp: pending plus condition +PASS: gdb.base/pending.exp: disable 1 +PASS: gdb.base/pending.exp: pending disabled +PASS: gdb.base/pending.exp: Set commands for pending breakpoint +PASS: gdb.base/pending.exp: pending disabled plus commands +PASS: gdb.base/pending.exp: Set pending breakpoint 2 +PASS: gdb.base/pending.exp: multiple pending breakpoints +PASS: gdb.base/pending.exp: Set pending breakpoint 3 +PASS: gdb.base/pending.exp: set ignore count on pending breakpoint 3 +PASS: gdb.base/pending.exp: multiple pending breakpoints 2 +PASS: gdb.base/pending.exp: running to main +PASS: gdb.base/pending.exp: re-enabling pending breakpoint that can resolve instantly +PASS: gdb.base/pending.exp: continue to resolved breakpoint 2 +PASS: gdb.base/pending.exp: continue to resolved breakpoint 1 +PASS: gdb.base/pending.exp: Disable other breakpoints +PASS: gdb.base/pending.exp: Disable other breakpoints +PASS: gdb.base/pending.exp: continue to resolved breakpoint 3 +PASS: gdb.base/pending.exp: set imaginary pending breakpoint +PASS: gdb.base/pending.exp: rerun to main +PASS: gdb.base/pending.exp: verify pending breakpoint after restart +Running ./gdb.base/permissions.exp ... +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: enable observer mode +PASS: gdb.base/permissions.exp: show may-write-memory +PASS: gdb.base/permissions.exp: show may-write-registers +PASS: gdb.base/permissions.exp: show may-insert-breakpoints +PASS: gdb.base/permissions.exp: show may-insert-tracepoints +PASS: gdb.base/permissions.exp: show may-insert-fast-tracepoints +PASS: gdb.base/permissions.exp: show may-interrupt +PASS: gdb.base/permissions.exp: disable observer mode +PASS: gdb.base/permissions.exp: set non-stop off +PASS: gdb.base/permissions.exp: set a global +PASS: gdb.base/permissions.exp: print x +PASS: gdb.base/permissions.exp: set may-write-memory off +PASS: gdb.base/permissions.exp: try to set a global +PASS: gdb.base/permissions.exp: print x +Running ./gdb.base/pie-execl.exp ... +Running ./gdb.base/pointers.exp ... +PASS: gdb.base/pointers.exp: continuing after dummy() +PASS: gdb.base/pointers.exp: set pointer to beginning of array +PASS: gdb.base/pointers.exp: set pointer to end of array +PASS: gdb.base/pointers.exp: print object pointed to +PASS: gdb.base/pointers.exp: print object pointed to #2 +PASS: gdb.base/pointers.exp: pointer1==pointer2 +PASS: gdb.base/pointers.exp: pointer1!=pointer2 +PASS: gdb.base/pointers.exp: pointer1<=pointer2 +PASS: gdb.base/pointers.exp: pointer1>=pointer2 +PASS: gdb.base/pointers.exp: pointer1<pointer2 +PASS: gdb.base/pointers.exp: pointer1>pointer2 +PASS: gdb.base/pointers.exp: set y = *v_int_pointer++ +PASS: gdb.base/pointers.exp: pointer assignment +PASS: gdb.base/pointers.exp: and post-increment +PASS: gdb.base/pointers.exp: set y = *--v_int_pointer2 +PASS: gdb.base/pointers.exp: pointer assignment +PASS: gdb.base/pointers.exp: and pre-decrement +PASS: gdb.base/pointers.exp: set y =v_int_pointer-v_int_pointer2 +PASS: gdb.base/pointers.exp: pointer1-pointer2 +PASS: gdb.base/pointers.exp: set v_int_pointer=v_int_array +PASS: gdb.base/pointers.exp: print array element through pointer +PASS: gdb.base/pointers.exp: print array element through pointer #2 +PASS: gdb.base/pointers.exp: print array element through pointer #3 +PASS: gdb.base/pointers.exp: print array element through pointer #4 +PASS: gdb.base/pointers.exp: print array element through pointer #5 +PASS: gdb.base/pointers.exp: increment rptr +PASS: gdb.base/pointers.exp: print array element through pointer #6 +PASS: gdb.base/pointers.exp: print array element through pointer #7 +PASS: gdb.base/pointers.exp: print array element through pointer #8 +PASS: gdb.base/pointers.exp: print array element w/ pointer arithmetic +PASS: gdb.base/pointers.exp: print through ptr to ptr +PASS: gdb.base/pointers.exp: continue +PASS: gdb.base/pointers.exp: up from marker1 +PASS: gdb.base/pointers.exp: print value of *pUC +PASS: gdb.base/pointers.exp: ptype pUC +PASS: gdb.base/pointers.exp: print value of *pS +PASS: gdb.base/pointers.exp: ptype pS +PASS: gdb.base/pointers.exp: print value of *pUS +PASS: gdb.base/pointers.exp: ptype pUS +PASS: gdb.base/pointers.exp: print value of *pI +PASS: gdb.base/pointers.exp: ptype pI +PASS: gdb.base/pointers.exp: print value of *pUI +PASS: gdb.base/pointers.exp: ptype pUI +PASS: gdb.base/pointers.exp: print value of *pL +PASS: gdb.base/pointers.exp: ptype pL +PASS: gdb.base/pointers.exp: print value of *pUL +PASS: gdb.base/pointers.exp: ptype pUL +PASS: gdb.base/pointers.exp: print value of *pF +PASS: gdb.base/pointers.exp: ptype pF +PASS: gdb.base/pointers.exp: print value of *pD +PASS: gdb.base/pointers.exp: ptype pD +PASS: gdb.base/pointers.exp: print value of ******ppppppC +PASS: gdb.base/pointers.exp: ptype pC +PASS: gdb.base/pointers.exp: ptype ppC +PASS: gdb.base/pointers.exp: ptype pppC +PASS: gdb.base/pointers.exp: ptype ppppC +PASS: gdb.base/pointers.exp: ptype pppppC +PASS: gdb.base/pointers.exp: ptype ppppppC +PASS: gdb.base/pointers.exp: p instance.array_variable + 0 +Running ./gdb.base/pr10179.exp ... +PASS: gdb.base/pr10179.exp: rbreak foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c:foo.* +PASS: gdb.base/pr10179.exp: rbreak pr10179-a.c : .* +Running ./gdb.base/pr11022.exp ... +Running ./gdb.base/prelink.exp ... +Running ./gdb.base/printcmds.exp ... +PASS: gdb.base/printcmds.exp: print $pc +PASS: gdb.base/printcmds.exp: print "abc" +PASS: gdb.base/printcmds.exp: print sizeof ("abc") +PASS: gdb.base/printcmds.exp: ptype "abc" +PASS: gdb.base/printcmds.exp: print $cvar = "abc" +PASS: gdb.base/printcmds.exp: print sizeof ($cvar) +PASS: gdb.base/printcmds.exp: print $pc (with file) +PASS: gdb.base/printcmds.exp: set print sevenbit-strings +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set width 0 +PASS: gdb.base/printcmds.exp: p ctable1[120] #1 +PASS: gdb.base/printcmds.exp: p 123 +PASS: gdb.base/printcmds.exp: p -123 +PASS: gdb.base/printcmds.exp: p/d 123 +PASS: gdb.base/printcmds.exp: p 0123 +PASS: gdb.base/printcmds.exp: p 00123 +PASS: gdb.base/printcmds.exp: p -0123 +PASS: gdb.base/printcmds.exp: p/o 0123 +PASS: gdb.base/printcmds.exp: p 0x123 +PASS: gdb.base/printcmds.exp: p -0x123 +PASS: gdb.base/printcmds.exp: p 0x0123 +PASS: gdb.base/printcmds.exp: p -0x0123 +PASS: gdb.base/printcmds.exp: p 0xABCDEF +PASS: gdb.base/printcmds.exp: p 0xabcdef +PASS: gdb.base/printcmds.exp: p 0xAbCdEf +PASS: gdb.base/printcmds.exp: p/x 0x123 +PASS: gdb.base/printcmds.exp: p 0b0 +PASS: gdb.base/printcmds.exp: p 0b1111 +PASS: gdb.base/printcmds.exp: p 0B1111 +PASS: gdb.base/printcmds.exp: p -0b1111 +PASS: gdb.base/printcmds.exp: reject p 0x +PASS: gdb.base/printcmds.exp: reject p 0b +PASS: gdb.base/printcmds.exp: p '' +PASS: gdb.base/printcmds.exp: p ''' +PASS: gdb.base/printcmds.exp: reject p '\' +PASS: gdb.base/printcmds.exp: reject p '\\\' +PASS: gdb.base/printcmds.exp: reject p DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 09 +PASS: gdb.base/printcmds.exp: reject p 079 +PASS: gdb.base/printcmds.exp: reject p 0xG +PASS: gdb.base/printcmds.exp: reject p 0xAG +PASS: gdb.base/printcmds.exp: reject p 0b2 +PASS: gdb.base/printcmds.exp: reject p 0b12 +PASS: gdb.base/printcmds.exp: check for floating addition +PASS: gdb.base/printcmds.exp: p 1. +PASS: gdb.base/printcmds.exp: p 1.5 +PASS: gdb.base/printcmds.exp: p 1.f +PASS: gdb.base/printcmds.exp: p 1.5f +PASS: gdb.base/printcmds.exp: p 1.l +PASS: gdb.base/printcmds.exp: p 1.5l +PASS: gdb.base/printcmds.exp: p 0x1.1 +PASS: gdb.base/printcmds.exp: reject p 123DEADBEEF +PASS: gdb.base/printcmds.exp: reject p 123foobar.bazfoo3 +PASS: gdb.base/printcmds.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.base/printcmds.exp: reject p 1.1x +PASS: gdb.base/printcmds.exp: reject p 1.1ff +PASS: gdb.base/printcmds.exp: reject p 1.1ll +PASS: gdb.base/printcmds.exp: p 'a' +PASS: gdb.base/printcmds.exp: p/c 'a' +PASS: gdb.base/printcmds.exp: p/x 'a' +PASS: gdb.base/printcmds.exp: p/d 'a' +PASS: gdb.base/printcmds.exp: p/t 'a' +PASS: gdb.base/printcmds.exp: p '\141' +PASS: gdb.base/printcmds.exp: p/x '\377' +PASS: gdb.base/printcmds.exp: p '\'' +PASS: gdb.base/printcmds.exp: p '\\' +PASS: gdb.base/printcmds.exp: p ctable1[0] +PASS: gdb.base/printcmds.exp: p ctable1[1] +PASS: gdb.base/printcmds.exp: p ctable1[2] +PASS: gdb.base/printcmds.exp: p ctable1[3] +PASS: gdb.base/printcmds.exp: p ctable1[4] +PASS: gdb.base/printcmds.exp: p ctable1[5] +PASS: gdb.base/printcmds.exp: p ctable1[6] +PASS: gdb.base/printcmds.exp: p ctable1[7] +PASS: gdb.base/printcmds.exp: p ctable1[8] +PASS: gdb.base/printcmds.exp: p ctable1[9] +PASS: gdb.base/printcmds.exp: p ctable1[10] +PASS: gdb.base/printcmds.exp: p ctable1[11] +PASS: gdb.base/printcmds.exp: p ctable1[12] +PASS: gdb.base/printcmds.exp: p ctable1[13] +PASS: gdb.base/printcmds.exp: p ctable1[14] +PASS: gdb.base/printcmds.exp: p ctable1[15] +PASS: gdb.base/printcmds.exp: p ctable1[16] +PASS: gdb.base/printcmds.exp: p ctable1[17] +PASS: gdb.base/printcmds.exp: p ctable1[18] +PASS: gdb.base/printcmds.exp: p ctable1[19] +PASS: gdb.base/printcmds.exp: p ctable1[20] +PASS: gdb.base/printcmds.exp: p ctable1[21] +PASS: gdb.base/printcmds.exp: p ctable1[22] +PASS: gdb.base/printcmds.exp: p ctable1[23] +PASS: gdb.base/printcmds.exp: p ctable1[24] +PASS: gdb.base/printcmds.exp: p ctable1[25] +PASS: gdb.base/printcmds.exp: p ctable1[26] +PASS: gdb.base/printcmds.exp: p ctable1[27] +PASS: gdb.base/printcmds.exp: p ctable1[28] +PASS: gdb.base/printcmds.exp: p ctable1[29] +PASS: gdb.base/printcmds.exp: p ctable1[30] +PASS: gdb.base/printcmds.exp: p ctable1[31] +PASS: gdb.base/printcmds.exp: p ctable1[32] +PASS: gdb.base/printcmds.exp: p ctable1[33] +PASS: gdb.base/printcmds.exp: p ctable1[34] +PASS: gdb.base/printcmds.exp: p ctable1[35] +PASS: gdb.base/printcmds.exp: p ctable1[36] +PASS: gdb.base/printcmds.exp: p ctable1[37] +PASS: gdb.base/printcmds.exp: p ctable1[38] +PASS: gdb.base/printcmds.exp: p ctable1[39] +PASS: gdb.base/printcmds.exp: p ctable1[40] +PASS: gdb.base/printcmds.exp: p ctable1[41] +PASS: gdb.base/printcmds.exp: p ctable1[42] +PASS: gdb.base/printcmds.exp: p ctable1[43] +PASS: gdb.base/printcmds.exp: p ctable1[44] +PASS: gdb.base/printcmds.exp: p ctable1[45] +PASS: gdb.base/printcmds.exp: p ctable1[46] +PASS: gdb.base/printcmds.exp: p ctable1[47] +PASS: gdb.base/printcmds.exp: p ctable1[48] +PASS: gdb.base/printcmds.exp: p ctable1[49] +PASS: gdb.base/printcmds.exp: p ctable1[50] +PASS: gdb.base/printcmds.exp: p ctable1[51] +PASS: gdb.base/printcmds.exp: p ctable1[52] +PASS: gdb.base/printcmds.exp: p ctable1[53] +PASS: gdb.base/printcmds.exp: p ctable1[54] +PASS: gdb.base/printcmds.exp: p ctable1[55] +PASS: gdb.base/printcmds.exp: p ctable1[56] +PASS: gdb.base/printcmds.exp: p ctable1[57] +PASS: gdb.base/printcmds.exp: p ctable1[58] +PASS: gdb.base/printcmds.exp: p ctable1[59] +PASS: gdb.base/printcmds.exp: p ctable1[60] +PASS: gdb.base/printcmds.exp: p ctable1[61] +PASS: gdb.base/printcmds.exp: p ctable1[62] +PASS: gdb.base/printcmds.exp: p ctable1[63] +PASS: gdb.base/printcmds.exp: p ctable1[64] +PASS: gdb.base/printcmds.exp: p ctable1[65] +PASS: gdb.base/printcmds.exp: p ctable1[66] +PASS: gdb.base/printcmds.exp: p ctable1[67] +PASS: gdb.base/printcmds.exp: p ctable1[68] +PASS: gdb.base/printcmds.exp: p ctable1[69] +PASS: gdb.base/printcmds.exp: p ctable1[70] +PASS: gdb.base/printcmds.exp: p ctable1[71] +PASS: gdb.base/printcmds.exp: p ctable1[72] +PASS: gdb.base/printcmds.exp: p ctable1[73] +PASS: gdb.base/printcmds.exp: p ctable1[74] +PASS: gdb.base/printcmds.exp: p ctable1[75] +PASS: gdb.base/printcmds.exp: p ctable1[76] +PASS: gdb.base/printcmds.exp: p ctable1[77] +PASS: gdb.base/printcmds.exp: p ctable1[78] +PASS: gdb.base/printcmds.exp: p ctable1[79] +PASS: gdb.base/printcmds.exp: p ctable1[80] +PASS: gdb.base/printcmds.exp: p ctable1[81] +PASS: gdb.base/printcmds.exp: p ctable1[82] +PASS: gdb.base/printcmds.exp: p ctable1[83] +PASS: gdb.base/printcmds.exp: p ctable1[84] +PASS: gdb.base/printcmds.exp: p ctable1[85] +PASS: gdb.base/printcmds.exp: p ctable1[86] +PASS: gdb.base/printcmds.exp: p ctable1[87] +PASS: gdb.base/printcmds.exp: p ctable1[88] +PASS: gdb.base/printcmds.exp: p ctable1[89] +PASS: gdb.base/printcmds.exp: p ctable1[90] +PASS: gdb.base/printcmds.exp: p ctable1[91] +PASS: gdb.base/printcmds.exp: p ctable1[92] +PASS: gdb.base/printcmds.exp: p ctable1[93] +PASS: gdb.base/printcmds.exp: p ctable1[94] +PASS: gdb.base/printcmds.exp: p ctable1[95] +PASS: gdb.base/printcmds.exp: p ctable1[96] +PASS: gdb.base/printcmds.exp: p ctable1[97] +PASS: gdb.base/printcmds.exp: p ctable1[98] +PASS: gdb.base/printcmds.exp: p ctable1[99] +PASS: gdb.base/printcmds.exp: p ctable1[100] +PASS: gdb.base/printcmds.exp: p ctable1[101] +PASS: gdb.base/printcmds.exp: p ctable1[102] +PASS: gdb.base/printcmds.exp: p ctable1[103] +PASS: gdb.base/printcmds.exp: p ctable1[104] +PASS: gdb.base/printcmds.exp: p ctable1[105] +PASS: gdb.base/printcmds.exp: p ctable1[106] +PASS: gdb.base/printcmds.exp: p ctable1[107] +PASS: gdb.base/printcmds.exp: p ctable1[108] +PASS: gdb.base/printcmds.exp: p ctable1[109] +PASS: gdb.base/printcmds.exp: p ctable1[110] +PASS: gdb.base/printcmds.exp: p ctable1[111] +PASS: gdb.base/printcmds.exp: p ctable1[112] +PASS: gdb.base/printcmds.exp: p ctable1[113] +PASS: gdb.base/printcmds.exp: p ctable1[114] +PASS: gdb.base/printcmds.exp: p ctable1[115] +PASS: gdb.base/printcmds.exp: p ctable1[116] +PASS: gdb.base/printcmds.exp: p ctable1[117] +PASS: gdb.base/printcmds.exp: p ctable1[118] +PASS: gdb.base/printcmds.exp: p ctable1[119] +PASS: gdb.base/printcmds.exp: p ctable1[120] +PASS: gdb.base/printcmds.exp: p ctable1[121] +PASS: gdb.base/printcmds.exp: p ctable1[122] +PASS: gdb.base/printcmds.exp: p ctable1[123] +PASS: gdb.base/printcmds.exp: p ctable1[124] +PASS: gdb.base/printcmds.exp: p ctable1[125] +PASS: gdb.base/printcmds.exp: p ctable1[126] +PASS: gdb.base/printcmds.exp: p ctable1[127] +PASS: gdb.base/printcmds.exp: p ctable1[128] +PASS: gdb.base/printcmds.exp: p ctable1[129] +PASS: gdb.base/printcmds.exp: p ctable1[130] +PASS: gdb.base/printcmds.exp: p ctable1[131] +PASS: gdb.base/printcmds.exp: p ctable1[132] +PASS: gdb.base/printcmds.exp: p ctable1[133] +PASS: gdb.base/printcmds.exp: p ctable1[134] +PASS: gdb.base/printcmds.exp: p ctable1[135] +PASS: gdb.base/printcmds.exp: p ctable1[136] +PASS: gdb.base/printcmds.exp: p ctable1[137] +PASS: gdb.base/printcmds.exp: p ctable1[138] +PASS: gdb.base/printcmds.exp: p ctable1[139] +PASS: gdb.base/printcmds.exp: p ctable1[140] +PASS: gdb.base/printcmds.exp: p ctable1[141] +PASS: gdb.base/printcmds.exp: p ctable1[142] +PASS: gdb.base/printcmds.exp: p ctable1[143] +PASS: gdb.base/printcmds.exp: p ctable1[144] +PASS: gdb.base/printcmds.exp: p ctable1[145] +PASS: gdb.base/printcmds.exp: p ctable1[146] +PASS: gdb.base/printcmds.exp: p ctable1[147] +PASS: gdb.base/printcmds.exp: p ctable1[148] +PASS: gdb.base/printcmds.exp: p ctable1[149] +PASS: gdb.base/printcmds.exp: p ctable1[150] +PASS: gdb.base/printcmds.exp: p ctable1[151] +PASS: gdb.base/printcmds.exp: p ctable1[152] +PASS: gdb.base/printcmds.exp: p ctable1[153] +PASS: gdb.base/printcmds.exp: p ctable1[154] +PASS: gdb.base/printcmds.exp: p ctable1[155] +PASS: gdb.base/printcmds.exp: p ctable1[156] +PASS: gdb.base/printcmds.exp: p ctable1[157] +PASS: gdb.base/printcmds.exp: p ctable1[158] +PASS: gdb.base/printcmds.exp: p ctable1[159] +PASS: gdb.base/printcmds.exp: p ctable1[160] +PASS: gdb.base/printcmds.exp: p ctable1[161] +PASS: gdb.base/printcmds.exp: p ctable1[162] +PASS: gdb.base/printcmds.exp: p ctable1[163] +PASS: gdb.base/printcmds.exp: p ctable1[164] +PASS: gdb.base/printcmds.exp: p ctable1[165] +PASS: gdb.base/printcmds.exp: p ctable1[166] +PASS: gdb.base/printcmds.exp: p ctable1[167] +PASS: gdb.base/printcmds.exp: p ctable1[168] +PASS: gdb.base/printcmds.exp: p ctable1[169] +PASS: gdb.base/printcmds.exp: p ctable1[170] +PASS: gdb.base/printcmds.exp: p ctable1[171] +PASS: gdb.base/printcmds.exp: p ctable1[172] +PASS: gdb.base/printcmds.exp: p ctable1[173] +PASS: gdb.base/printcmds.exp: p ctable1[174] +PASS: gdb.base/printcmds.exp: p ctable1[175] +PASS: gdb.base/printcmds.exp: p ctable1[176] +PASS: gdb.base/printcmds.exp: p ctable1[177] +PASS: gdb.base/printcmds.exp: p ctable1[178] +PASS: gdb.base/printcmds.exp: p ctable1[179] +PASS: gdb.base/printcmds.exp: p ctable1[180] +PASS: gdb.base/printcmds.exp: p ctable1[181] +PASS: gdb.base/printcmds.exp: p ctable1[182] +PASS: gdb.base/printcmds.exp: p ctable1[183] +PASS: gdb.base/printcmds.exp: p ctable1[184] +PASS: gdb.base/printcmds.exp: p ctable1[185] +PASS: gdb.base/printcmds.exp: p ctable1[186] +PASS: gdb.base/printcmds.exp: p ctable1[187] +PASS: gdb.base/printcmds.exp: p ctable1[188] +PASS: gdb.base/printcmds.exp: p ctable1[189] +PASS: gdb.base/printcmds.exp: p ctable1[190] +PASS: gdb.base/printcmds.exp: p ctable1[191] +PASS: gdb.base/printcmds.exp: p ctable1[192] +PASS: gdb.base/printcmds.exp: p ctable1[193] +PASS: gdb.base/printcmds.exp: p ctable1[194] +PASS: gdb.base/printcmds.exp: p ctable1[195] +PASS: gdb.base/printcmds.exp: p ctable1[196] +PASS: gdb.base/printcmds.exp: p ctable1[197] +PASS: gdb.base/printcmds.exp: p ctable1[198] +PASS: gdb.base/printcmds.exp: p ctable1[199] +PASS: gdb.base/printcmds.exp: p ctable1[200] +PASS: gdb.base/printcmds.exp: p ctable1[201] +PASS: gdb.base/printcmds.exp: p ctable1[202] +PASS: gdb.base/printcmds.exp: p ctable1[203] +PASS: gdb.base/printcmds.exp: p ctable1[204] +PASS: gdb.base/printcmds.exp: p ctable1[205] +PASS: gdb.base/printcmds.exp: p ctable1[206] +PASS: gdb.base/printcmds.exp: p ctable1[207] +PASS: gdb.base/printcmds.exp: p ctable1[208] +PASS: gdb.base/printcmds.exp: p ctable1[209] +PASS: gdb.base/printcmds.exp: p ctable1[210] +PASS: gdb.base/printcmds.exp: p ctable1[211] +PASS: gdb.base/printcmds.exp: p ctable1[212] +PASS: gdb.base/printcmds.exp: p ctable1[213] +PASS: gdb.base/printcmds.exp: p ctable1[214] +PASS: gdb.base/printcmds.exp: p ctable1[215] +PASS: gdb.base/printcmds.exp: p ctable1[216] +PASS: gdb.base/printcmds.exp: p ctable1[217] +PASS: gdb.base/printcmds.exp: p ctable1[218] +PASS: gdb.base/printcmds.exp: p ctable1[219] +PASS: gdb.base/printcmds.exp: p ctable1[220] +PASS: gdb.base/printcmds.exp: p ctable1[221] +PASS: gdb.base/printcmds.exp: p ctable1[222] +PASS: gdb.base/printcmds.exp: p ctable1[223] +PASS: gdb.base/printcmds.exp: p ctable1[224] +PASS: gdb.base/printcmds.exp: p ctable1[225] +PASS: gdb.base/printcmds.exp: p ctable1[226] +PASS: gdb.base/printcmds.exp: p ctable1[227] +PASS: gdb.base/printcmds.exp: p ctable1[228] +PASS: gdb.base/printcmds.exp: p ctable1[229] +PASS: gdb.base/printcmds.exp: p ctable1[230] +PASS: gdb.base/printcmds.exp: p ctable1[231] +PASS: gdb.base/printcmds.exp: p ctable1[232] +PASS: gdb.base/printcmds.exp: p ctable1[233] +PASS: gdb.base/printcmds.exp: p ctable1[234] +PASS: gdb.base/printcmds.exp: p ctable1[235] +PASS: gdb.base/printcmds.exp: p ctable1[236] +PASS: gdb.base/printcmds.exp: p ctable1[237] +PASS: gdb.base/printcmds.exp: p ctable1[238] +PASS: gdb.base/printcmds.exp: p ctable1[239] +PASS: gdb.base/printcmds.exp: p ctable1[240] +PASS: gdb.base/printcmds.exp: p ctable1[241] +PASS: gdb.base/printcmds.exp: p ctable1[242] +PASS: gdb.base/printcmds.exp: p ctable1[243] +PASS: gdb.base/printcmds.exp: p ctable1[244] +PASS: gdb.base/printcmds.exp: p ctable1[245] +PASS: gdb.base/printcmds.exp: p ctable1[246] +PASS: gdb.base/printcmds.exp: p ctable1[247] +PASS: gdb.base/printcmds.exp: p ctable1[248] +PASS: gdb.base/printcmds.exp: p ctable1[249] +PASS: gdb.base/printcmds.exp: p ctable1[250] +PASS: gdb.base/printcmds.exp: p ctable1[251] +PASS: gdb.base/printcmds.exp: p ctable1[252] +PASS: gdb.base/printcmds.exp: p ctable1[253] +PASS: gdb.base/printcmds.exp: p ctable1[254] +PASS: gdb.base/printcmds.exp: p ctable1[255] +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 2 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 2 +PASS: gdb.base/printcmds.exp: set print elements 3 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 3 +PASS: gdb.base/printcmds.exp: set print elements 4 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 4 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 6 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 6 +PASS: gdb.base/printcmds.exp: set print elements 7 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 7 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 8 +PASS: gdb.base/printcmds.exp: set print elements 9 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 9 +PASS: gdb.base/printcmds.exp: set print elements 10 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 10 +PASS: gdb.base/printcmds.exp: set print elements 11 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 11 +PASS: gdb.base/printcmds.exp: set print elements 12 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 12 +PASS: gdb.base/printcmds.exp: set print elements 13 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 13 +PASS: gdb.base/printcmds.exp: set print elements 14 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 14 +PASS: gdb.base/printcmds.exp: set print elements 15 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 15 +PASS: gdb.base/printcmds.exp: set print elements 16 +PASS: gdb.base/printcmds.exp: p &ctable2[0*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[1*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[2*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[3*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[4*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[5*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[6*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[7*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[8*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[9*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[10*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[11*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[12*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[13*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[14*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: p &ctable2[15*16] with print elements set to 16 +PASS: gdb.base/printcmds.exp: correct element repeats in array embedded at offset > 0 +PASS: gdb.base/printcmds.exp: set print elements 0 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 0 +PASS: gdb.base/printcmds.exp: set print elements 1 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 1 +PASS: gdb.base/printcmds.exp: set print elements 5 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 5 +PASS: gdb.base/printcmds.exp: set print elements 19 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 19 +PASS: gdb.base/printcmds.exp: set print elements 20 +PASS: gdb.base/printcmds.exp: p teststring with elements set to 20 +PASS: gdb.base/printcmds.exp: set print elements 8 +PASS: gdb.base/printcmds.exp: p &ctable1[0] +PASS: gdb.base/printcmds.exp: p &ctable1[1] +PASS: gdb.base/printcmds.exp: p &ctable1[1*8] +PASS: gdb.base/printcmds.exp: p &ctable1[2*8] +PASS: gdb.base/printcmds.exp: p &ctable1[3*8] +PASS: gdb.base/printcmds.exp: p &ctable1[4*8] +PASS: gdb.base/printcmds.exp: p &ctable1[5*8] +PASS: gdb.base/printcmds.exp: p &ctable1[6*8] +PASS: gdb.base/printcmds.exp: p &ctable1[7*8] +PASS: gdb.base/printcmds.exp: p &ctable1[8*8] +PASS: gdb.base/printcmds.exp: p &ctable1[9*8] +PASS: gdb.base/printcmds.exp: p &ctable1[10*8] +PASS: gdb.base/printcmds.exp: p &ctable1[11*8] +PASS: gdb.base/printcmds.exp: p &ctable1[12*8] +PASS: gdb.base/printcmds.exp: p &ctable1[13*8] +PASS: gdb.base/printcmds.exp: p &ctable1[14*8] +PASS: gdb.base/printcmds.exp: p &ctable1[15*8] +PASS: gdb.base/printcmds.exp: p &ctable1[16*8] +PASS: gdb.base/printcmds.exp: p &ctable1[17*8] +PASS: gdb.base/printcmds.exp: p &ctable1[18*8] +PASS: gdb.base/printcmds.exp: p &ctable1[19*8] +PASS: gdb.base/printcmds.exp: p &ctable1[20*8] +PASS: gdb.base/printcmds.exp: p &ctable1[21*8] +PASS: gdb.base/printcmds.exp: p &ctable1[22*8] +PASS: gdb.base/printcmds.exp: p &ctable1[23*8] +PASS: gdb.base/printcmds.exp: p &ctable1[24*8] +PASS: gdb.base/printcmds.exp: p &ctable1[25*8] +PASS: gdb.base/printcmds.exp: p &ctable1[26*8] +PASS: gdb.base/printcmds.exp: p &ctable1[27*8] +PASS: gdb.base/printcmds.exp: p &ctable1[28*8] +PASS: gdb.base/printcmds.exp: p &ctable1[29*8] +PASS: gdb.base/printcmds.exp: p &ctable1[30*8] +PASS: gdb.base/printcmds.exp: p &ctable1[31*8] +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: p a1[0] +PASS: gdb.base/printcmds.exp: p a1[9] +PASS: gdb.base/printcmds.exp: p a2 +PASS: gdb.base/printcmds.exp: p a2[0] +PASS: gdb.base/printcmds.exp: p a2[3] +PASS: gdb.base/printcmds.exp: set print null-stop on +PASS: gdb.base/printcmds.exp: print a2 with null-stop on +PASS: gdb.base/printcmds.exp: set print null-stop off +PASS: gdb.base/printcmds.exp: p int1dim[0]@2 +PASS: gdb.base/printcmds.exp: p int1dim[0]@2@3 +PASS: gdb.base/printcmds.exp: set print elements 24 +PASS: gdb.base/printcmds.exp: set print address on +PASS: gdb.base/printcmds.exp: p arrays +PASS: gdb.base/printcmds.exp: p parrays +PASS: gdb.base/printcmds.exp: p parrays->array1 +PASS: gdb.base/printcmds.exp: p &parrays->array1 +PASS: gdb.base/printcmds.exp: p parrays->array2 +PASS: gdb.base/printcmds.exp: p &parrays->array2 +PASS: gdb.base/printcmds.exp: p parrays->array3 +PASS: gdb.base/printcmds.exp: p &parrays->array3 +PASS: gdb.base/printcmds.exp: p parrays->array4 +PASS: gdb.base/printcmds.exp: p &parrays->array4 +PASS: gdb.base/printcmds.exp: p parrays->array5 +PASS: gdb.base/printcmds.exp: p &parrays->array5 +PASS: gdb.base/printcmds.exp: set print address off +PASS: gdb.base/printcmds.exp: set print elements 50 +PASS: gdb.base/printcmds.exp: p "a string" +PASS: gdb.base/printcmds.exp: p "embedded \000 null" +PASS: gdb.base/printcmds.exp: p "abcd"[2] +PASS: gdb.base/printcmds.exp: p sizeof ("abcdef") +PASS: gdb.base/printcmds.exp: ptype "foo" +PASS: gdb.base/printcmds.exp: p *"foo" +PASS: gdb.base/printcmds.exp: ptype *"foo" +PASS: gdb.base/printcmds.exp: p &*"foo" +PASS: gdb.base/printcmds.exp: ptype &*"foo" +PASS: gdb.base/printcmds.exp: p (char *)"foo" +PASS: gdb.base/printcmds.exp: print {'a','b','c'} +PASS: gdb.base/printcmds.exp: print {4,5,6}[2] +PASS: gdb.base/printcmds.exp: print *&{4,5,6}[1] +PASS: gdb.base/printcmds.exp: print some_volatile_enum +PASS: gdb.base/printcmds.exp: print three +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%d,z=%d\n", 5, 6, 7 +PASS: gdb.base/printcmds.exp: printf "string=%.4sxx\n", teststring +PASS: gdb.base/printcmds.exp: printf "string=%sxx\n", teststring +PASS: gdb.base/printcmds.exp: printf "%f is fun\n", 1.0 +PASS: gdb.base/printcmds.exp: printf "x=%d,y=%f,z=%d\n", 5, 6.0, 7 +PASS: gdb.base/printcmds.exp: printf "%x %f, %c %x, %x, %f\n", 0xbad, -99.541, 'z', 0xfeedface, 0xdeadbeef, 5.0 +PASS: gdb.base/printcmds.exp: printf "%c\n", "x"[1,0] +PASS: gdb.base/printcmds.exp: printf "%%%d%%\n", 5 +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.2df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1.234567df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",-1234567.df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E1df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E-10df +PASS: gdb.base/printcmds.exp: printf "%Hf\n",1.2E96df +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.2dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1.234567890123456dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",-1234567890123456.dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E1dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E-10dd +PASS: gdb.base/printcmds.exp: printf "%Df\n",1.2E384dd +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.2dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1.234567890123456789012345678901234dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",-1234567890123456789012345678901234.dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E1dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E-10dl +PASS: gdb.base/printcmds.exp: printf "%DDf\n",1.2E6144dl +PASS: gdb.base/printcmds.exp: printf "%Hf %Hf\n",1.2df,1.3df +PASS: gdb.base/printcmds.exp: set print symbol on +PASS: gdb.base/printcmds.exp: print &three +PASS: gdb.base/printcmds.exp: print parrays +PASS: gdb.base/printcmds.exp: set print symbol off +PASS: gdb.base/printcmds.exp: print invalid_LLL +PASS: gdb.base/printcmds.exp: print invalid_LLE +PASS: gdb.base/printcmds.exp: print invalid_LLR +PASS: gdb.base/printcmds.exp: print invalid_LLS +PASS: gdb.base/printcmds.exp: print invalid_ELL +PASS: gdb.base/printcmds.exp: print invalid_ELR +PASS: gdb.base/printcmds.exp: print invalid_ELS +PASS: gdb.base/printcmds.exp: print invalid_RLL +PASS: gdb.base/printcmds.exp: print invalid_RLE +PASS: gdb.base/printcmds.exp: print invalid_RLR +PASS: gdb.base/printcmds.exp: print invalid_RLS +PASS: gdb.base/printcmds.exp: print invalid_SLL +PASS: gdb.base/printcmds.exp: print invalid_SLE +PASS: gdb.base/printcmds.exp: print invalid_SLR +PASS: gdb.base/printcmds.exp: print invalid_SLS +PASS: gdb.base/printcmds.exp: print invalid_LRL +PASS: gdb.base/printcmds.exp: print invalid_LRE +PASS: gdb.base/printcmds.exp: print invalid_LRR +PASS: gdb.base/printcmds.exp: print invalid_LRS +PASS: gdb.base/printcmds.exp: print invalid_ERL +PASS: gdb.base/printcmds.exp: print invalid_ERR +PASS: gdb.base/printcmds.exp: print invalid_ERS +PASS: gdb.base/printcmds.exp: print invalid_RRL +PASS: gdb.base/printcmds.exp: print invalid_RRE +PASS: gdb.base/printcmds.exp: print invalid_RRR +PASS: gdb.base/printcmds.exp: print invalid_RRS +PASS: gdb.base/printcmds.exp: print invalid_SRL +PASS: gdb.base/printcmds.exp: print invalid_SRE +PASS: gdb.base/printcmds.exp: print invalid_SRR +PASS: gdb.base/printcmds.exp: print invalid_SRS +PASS: gdb.base/printcmds.exp: print invalid_LSL +PASS: gdb.base/printcmds.exp: print invalid_LSE +PASS: gdb.base/printcmds.exp: print invalid_LSR +PASS: gdb.base/printcmds.exp: print invalid_LSS +PASS: gdb.base/printcmds.exp: print invalid_ESL +PASS: gdb.base/printcmds.exp: print invalid_ESR +PASS: gdb.base/printcmds.exp: print invalid_ESS +PASS: gdb.base/printcmds.exp: print invalid_RSL +PASS: gdb.base/printcmds.exp: print invalid_RSE +PASS: gdb.base/printcmds.exp: print invalid_RSR +PASS: gdb.base/printcmds.exp: print invalid_RSS +PASS: gdb.base/printcmds.exp: print invalid_SSL +PASS: gdb.base/printcmds.exp: print invalid_SSE +PASS: gdb.base/printcmds.exp: print invalid_SSR +PASS: gdb.base/printcmds.exp: print invalid_SSS +Running ./gdb.base/print-file-var.exp ... +PASS: gdb.base/print-file-var.exp: breapoint past v1 & v2 initialization +PASS: gdb.base/print-file-var.exp: continue to STOP marker +PASS: gdb.base/print-file-var.exp: print 'print-file-var-lib1.c'::this_version_id == v1 +PASS: gdb.base/print-file-var.exp: print 'print-file-var-lib2.c'::this_version_id == v2 +Running ./gdb.base/prologue.exp ... +PASS: gdb.base/prologue.exp: setting breakpoint at marker +PASS: gdb.base/prologue.exp: continue to marker +PASS: gdb.base/prologue.exp: reading $pc: marker +PASS: gdb.base/prologue.exp: setting breakpoint at other +PASS: gdb.base/prologue.exp: continue to other +PASS: gdb.base/prologue.exp: reading $pc: other +PASS: gdb.base/prologue.exp: same pc from minimal symbol +Running ./gdb.base/prologue-include.exp ... +PASS: gdb.base/prologue-include.exp: breakpoint main +Running ./gdb.base/psymtab.exp ... +PASS: gdb.base/psymtab.exp: psymtab pending setup +PASS: gdb.base/psymtab.exp: Don't search past end of psymtab. +Running ./gdb.base/ptr-typedef.exp ... +PASS: gdb.base/ptr-typedef.exp: print foo_ptr +PASS: gdb.base/ptr-typedef.exp: print foz_ptr +Running ./gdb.base/ptype.exp ... +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member +PASS: gdb.base/ptype.exp: ptype structure +PASS: gdb.base/ptype.exp: ptype v_struct1.v_float_member +PASS: gdb.base/ptype.exp: ptype v_struct1->v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p.v_float_member +PASS: gdb.base/ptype.exp: ptype v_t_struct_p->v_float_member +PASS: gdb.base/ptype.exp: ptype linked list structure +PASS: gdb.base/ptype.exp: ptype union +PASS: gdb.base/ptype.exp: ptype linked list union +PASS: gdb.base/ptype.exp: ptype unnamed enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration +PASS: gdb.base/ptype.exp: ptype unnamed typedef'd enumeration +PASS: gdb.base/ptype.exp: list main +PASS: gdb.base/ptype.exp: whatis unnamed typedef'd enum (compiler bug in IBM's xlc) +PASS: gdb.base/ptype.exp: printing typedef'd struct +PASS: gdb.base/ptype.exp: printing typedef'd union +PASS: gdb.base/ptype.exp: ptype named typedef'd enumf'd enum +PASS: gdb.base/ptype.exp: ptype misordered enumeration +PASS: gdb.base/ptype.exp: ptype named enumeration member +PASS: gdb.base/ptype.exp: ptype unnamed enumeration member #2 +PASS: gdb.base/ptype.exp: ptype short +PASS: gdb.base/ptype.exp: ptype int +PASS: gdb.base/ptype.exp: ptype t_char_array +PASS: gdb.base/ptype.exp: ptype pv_char_array +PASS: gdb.base/ptype.exp: ptype outer structure +PASS: gdb.base/ptype.exp: ptype inner structure +PASS: gdb.base/ptype.exp: ptype inner union +PASS: gdb.base/ptype.exp: ptype nested structure +PASS: gdb.base/ptype.exp: ptype outer int +PASS: gdb.base/ptype.exp: ptype nested structure #2 +PASS: gdb.base/ptype.exp: ptype inner int +PASS: gdb.base/ptype.exp: ptype nested union +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype the_highest +PASS: gdb.base/ptype.exp: ptype func_type +PASS: gdb.base/ptype.exp: ptype old_fptr +PASS: gdb.base/ptype.exp: ptype new_fptr +PASS: gdb.base/ptype.exp: ptype fptr +PASS: gdb.base/ptype.exp: ptype fptr2 +PASS: gdb.base/ptype.exp: ptype xptr +PASS: gdb.base/ptype.exp: ptype ffptr +PASS: gdb.base/ptype.exp: ptype fffptr +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after first list of charfoo +PASS: gdb.base/ptype.exp: list intfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of intfoo +PASS: gdb.base/ptype.exp: list charfoo +PASS: gdb.base/ptype.exp: ptype foo typedef after second list of charfoo +PASS: gdb.base/ptype.exp: ptype "abc" +PASS: gdb.base/ptype.exp: ptype {'a','b','c'} +PASS: gdb.base/ptype.exp: ptype {0,1,2} +PASS: gdb.base/ptype.exp: ptype {(long)0,(long)1,(long)2} +PASS: gdb.base/ptype.exp: ptype {(float)0,(float)1,(float)2} +PASS: gdb.base/ptype.exp: ptype {{0,1,2},{3,4,5}} +PASS: gdb.base/ptype.exp: ptype {4,5,6}[2] +PASS: gdb.base/ptype.exp: ptype *&{4,5,6}[1] +PASS: gdb.base/ptype.exp: ptype $pc +Running ./gdb.base/radix.exp ... +PASS: gdb.base/radix.exp: initialize radix, input radix 2 +PASS: gdb.base/radix.exp: set input-radix 2 +PASS: gdb.base/radix.exp: show radix, input radix 2 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 2 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 2 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 2 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 2 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 2 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 2 +PASS: gdb.base/radix.exp: print 10; expect 2; input radix 2 +PASS: gdb.base/radix.exp: print 11; expect 3; input radix 2 +PASS: gdb.base/radix.exp: print -10; expect -2; input radix 2 +PASS: gdb.base/radix.exp: print -11; expect -3; input radix 2 +PASS: gdb.base/radix.exp: print 100; expect 4; input radix 2 +PASS: gdb.base/radix.exp: print 101; expect 5; input radix 2 +PASS: gdb.base/radix.exp: print -100; expect -4; input radix 2 +PASS: gdb.base/radix.exp: print -101; expect -5; input radix 2 +PASS: gdb.base/radix.exp: print 10101; expect 21; input radix 2 +PASS: gdb.base/radix.exp: print 4; expect Invalid number "4"\.; input radix 2 +PASS: gdb.base/radix.exp: print -2; expect Invalid number "2"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 3 +PASS: gdb.base/radix.exp: set input-radix 3 +PASS: gdb.base/radix.exp: show radix, input radix 3 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 3 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 3 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 3 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 3 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 3 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 3 +PASS: gdb.base/radix.exp: print 10; expect 3; input radix 3 +PASS: gdb.base/radix.exp: print 11; expect 4; input radix 3 +PASS: gdb.base/radix.exp: print -10; expect -3; input radix 3 +PASS: gdb.base/radix.exp: print -11; expect -4; input radix 3 +PASS: gdb.base/radix.exp: print 100; expect 9; input radix 3 +PASS: gdb.base/radix.exp: print 101; expect 10; input radix 3 +PASS: gdb.base/radix.exp: print -100; expect -9; input radix 3 +PASS: gdb.base/radix.exp: print -101; expect -10; input radix 3 +PASS: gdb.base/radix.exp: print 10101; expect 91; input radix 3 +PASS: gdb.base/radix.exp: print 2; expect 2; input radix 3 +PASS: gdb.base/radix.exp: print 20; expect 6; input radix 3 +PASS: gdb.base/radix.exp: print 3; expect Invalid number "3"\.; input radix 3 +PASS: gdb.base/radix.exp: print 30; expect Invalid number "30"\.; input radix 2 +PASS: gdb.base/radix.exp: initialize radix, input radix 8 +PASS: gdb.base/radix.exp: set input-radix 8 +PASS: gdb.base/radix.exp: show radix, input radix 8 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 8 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 8 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 8 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 8 +PASS: gdb.base/radix.exp: print 10; expect 8; input radix 8 +PASS: gdb.base/radix.exp: print 11; expect 9; input radix 8 +PASS: gdb.base/radix.exp: print -10; expect -8; input radix 8 +PASS: gdb.base/radix.exp: print -11; expect -9; input radix 8 +PASS: gdb.base/radix.exp: print 100; expect 64; input radix 8 +PASS: gdb.base/radix.exp: print 101; expect 65; input radix 8 +PASS: gdb.base/radix.exp: print -100; expect -64; input radix 8 +PASS: gdb.base/radix.exp: print -101; expect -65; input radix 8 +PASS: gdb.base/radix.exp: print 10101; expect 4161; input radix 8 +PASS: gdb.base/radix.exp: print 20; expect 16; input radix 8 +PASS: gdb.base/radix.exp: print -20; expect -16; input radix 8 +PASS: gdb.base/radix.exp: print 8; expect Invalid number "8".; input radix 8 +PASS: gdb.base/radix.exp: print -9; expect Invalid number "9".; input radix 8 +PASS: gdb.base/radix.exp: initialize radix, input radix 10 +PASS: gdb.base/radix.exp: set input-radix 10 +PASS: gdb.base/radix.exp: show radix, input radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 10 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 10 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 10 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; input radix 10 +PASS: gdb.base/radix.exp: print 11; expect 11; input radix 10 +PASS: gdb.base/radix.exp: print -10; expect -10; input radix 10 +PASS: gdb.base/radix.exp: print -11; expect -11; input radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; input radix 10 +PASS: gdb.base/radix.exp: print 101; expect 101; input radix 10 +PASS: gdb.base/radix.exp: print -100; expect -100; input radix 10 +PASS: gdb.base/radix.exp: print -101; expect -101; input radix 10 +PASS: gdb.base/radix.exp: print 10101; expect 10101; input radix 10 +PASS: gdb.base/radix.exp: print -12; expect -12; input radix 10 +PASS: gdb.base/radix.exp: initialize radix, input radix 16 +PASS: gdb.base/radix.exp: set input-radix 16 +PASS: gdb.base/radix.exp: show radix, input radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; input radix 16 +PASS: gdb.base/radix.exp: print 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; input radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect 15; input radix 16 +PASS: gdb.base/radix.exp: print 0; expect 0; input radix 16 +PASS: gdb.base/radix.exp: print 1; expect 1; input radix 16 +PASS: gdb.base/radix.exp: print -1; expect -1; input radix 16 +PASS: gdb.base/radix.exp: print 10; expect 16; input radix 16 +PASS: gdb.base/radix.exp: print 11; expect 17; input radix 16 +PASS: gdb.base/radix.exp: print -10; expect -16; input radix 16 +PASS: gdb.base/radix.exp: print -11; expect -17; input radix 16 +PASS: gdb.base/radix.exp: print 100; expect 256; input radix 16 +PASS: gdb.base/radix.exp: print 101; expect 257; input radix 16 +PASS: gdb.base/radix.exp: print -100; expect -256; input radix 16 +PASS: gdb.base/radix.exp: print -101; expect -257; input radix 16 +PASS: gdb.base/radix.exp: print 10101; expect 65793; input radix 16 +PASS: gdb.base/radix.exp: initialize radix, output radix 8 +PASS: gdb.base/radix.exp: set output-radix 8 +PASS: gdb.base/radix.exp: show radix, output radix 8 +PASS: gdb.base/radix.exp: print 010; expect 010; output radix 8 +PASS: gdb.base/radix.exp: print 0xf; expect 17; output radix 8 +PASS: gdb.base/radix.exp: print 10; expect 12; output radix 8 +PASS: gdb.base/radix.exp: print 100; expect 144; output radix 8 +KFAIL: gdb.base/radix.exp: print 20.; expect 24; output radix 8 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 24; output radix 8 +PASS: gdb.base/radix.exp: initialize radix, output radix 10 +PASS: gdb.base/radix.exp: set output-radix 10 +PASS: gdb.base/radix.exp: show radix, output radix 10 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 10 +PASS: gdb.base/radix.exp: print 0xf; expect 15; output radix 10 +PASS: gdb.base/radix.exp: print 10; expect 10; output radix 10 +PASS: gdb.base/radix.exp: print 100; expect 100; output radix 10 +PASS: gdb.base/radix.exp: print 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: print (int) 20.; expect 20; output radix 10 +PASS: gdb.base/radix.exp: initialize radix, output radix 16 +PASS: gdb.base/radix.exp: set output-radix 16 +PASS: gdb.base/radix.exp: show radix, output radix 16 +PASS: gdb.base/radix.exp: print 010; expect 8; output radix 16 +PASS: gdb.base/radix.exp: print 0xf; expect f; output radix 16 +PASS: gdb.base/radix.exp: print 10; expect a; output radix 16 +PASS: gdb.base/radix.exp: print 100; expect 64; output radix 16 +KFAIL: gdb.base/radix.exp: print 20.; expect 14; output radix 16 (PRMS: gdb/1715) +PASS: gdb.base/radix.exp: print (int) 20.; expect 14; output radix 16 +PASS: gdb.base/radix.exp: Reset radices +PASS: gdb.base/radix.exp: Reject input-radix 0 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject input-radix 1 +PASS: gdb.base/radix.exp: Input radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: Reject output-radix 0 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 0 +PASS: gdb.base/radix.exp: Reject output-radix 1 +PASS: gdb.base/radix.exp: Output radix unchanged after rejecting 1 +PASS: gdb.base/radix.exp: set radix 7 rejected +PASS: gdb.base/radix.exp: Output radix unchanged after rejection through set radix command +Running ./gdb.base/randomize.exp ... +UNTESTED: gdb.base/randomize.exp: Disabling randomization is not supported on this Linux GDB +Running ./gdb.base/random-signal.exp ... +PASS: gdb.base/random-signal.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/random-signal.exp: watch v +PASS: gdb.base/random-signal.exp: continue +FAIL: gdb.base/random-signal.exp: stop with control-c +Running ./gdb.base/readline-ask.exp ... +PASS: gdb.base/readline-ask.exp: set width 50 +PASS: gdb.base/readline-ask.exp: set height 3 +PASS: gdb.base/readline-ask.exp: bell for more message +FAIL: gdb.base/readline-ask.exp: more message for 01 and 02 +FAIL: gdb.base/readline-ask.exp: more message for 03 +FAIL: gdb.base/readline-ask.exp: more finish for 04 +ERROR: Undefined command "foo". +UNRESOLVED: gdb.base/readline-ask.exp: abort more message +PASS: gdb.base/readline-ask.exp: bell for ask message +FAIL: gdb.base/readline-ask.exp: ask message +Running ./gdb.base/readline.exp ... +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 1 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 2 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 3 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - send end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-p to if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for if 1 > 0 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for p 5 +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - C-o for end +PASS: gdb.base/readline.exp: operate-and-get-next with secondary prompt - final prompt +PASS: gdb.base/readline.exp: print 42 +PASS: gdb.base/readline.exp: arrow keys with secondary prompt +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - send p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-p to p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 7 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 8 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - C-o for p 9 +PASS: gdb.base/readline.exp: Simple operate-and-get-next - final prompt +Running ./gdb.base/realname-expand.exp ... +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: rbreak realname-expand-real.c:func +PASS: gdb.base/realname-expand.exp: set basenames-may-differ on +PASS: gdb.base/realname-expand.exp: break realname-expand-real.c:func +Running ./gdb.base/recpar.exp ... +PASS: gdb.base/recpar.exp: break recpar.c:26 if n == 3 +PASS: gdb.base/recpar.exp: continue +PASS: gdb.base/recpar.exp: backtrace +PASS: gdb.base/recpar.exp: frame 2 +PASS: gdb.base/recpar.exp: print foo::val +Running ./gdb.base/recurse.exp ... +PASS: gdb.base/recurse.exp: next over b = 0 in first instance +PASS: gdb.base/recurse.exp: set first instance watchpoint +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 9) +PASS: gdb.base/recurse.exp: continue to recurse (a = 8) +PASS: gdb.base/recurse.exp: continue to recurse (a = 7) +PASS: gdb.base/recurse.exp: continue to recurse (a = 6) +PASS: gdb.base/recurse.exp: continue to recurse (a = 5) +PASS: gdb.base/recurse.exp: next over b = 0 in second instance +PASS: gdb.base/recurse.exp: set second instance watchpoint +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, first time +PASS: gdb.base/recurse.exp: continue to recurse (a = 4) +PASS: gdb.base/recurse.exp: continue to recurse (a = 3) +PASS: gdb.base/recurse.exp: continue to recurse (a = 2) +PASS: gdb.base/recurse.exp: continue to recurse (a = 1) +PASS: gdb.base/recurse.exp: continue to second instance watchpoint, second time +PASS: gdb.base/recurse.exp: second instance watchpoint deleted when leaving scope +PASS: gdb.base/recurse.exp: continue to first instance watchpoint, second time +PASS: gdb.base/recurse.exp: first instance watchpoint deleted when leaving scope +Running ./gdb.base/relational.exp ... +PASS: gdb.base/relational.exp: set variable x=14 +PASS: gdb.base/relational.exp: set variable y=2 +PASS: gdb.base/relational.exp: set variable z=2 +PASS: gdb.base/relational.exp: set variable w=3 +PASS: gdb.base/relational.exp: print value of x +PASS: gdb.base/relational.exp: print value of y +PASS: gdb.base/relational.exp: print value of z +PASS: gdb.base/relational.exp: print value of w +PASS: gdb.base/relational.exp: print value of x<y +PASS: gdb.base/relational.exp: print value of x<=y +PASS: gdb.base/relational.exp: print value of x>y +PASS: gdb.base/relational.exp: print value of x>=y +PASS: gdb.base/relational.exp: print value of x==y +PASS: gdb.base/relational.exp: print value of x!=y +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<z +PASS: gdb.base/relational.exp: print value of x<=y<=z +PASS: gdb.base/relational.exp: print value of x>y>z +PASS: gdb.base/relational.exp: print value of x>=y>=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x==y==z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x!=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y==z +PASS: gdb.base/relational.exp: print value of x<y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable y +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y<=z +PASS: gdb.base/relational.exp: print value of x<y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x<y>z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>y>=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>y!=z +PASS: gdb.base/relational.exp: set x to 4 +PASS: gdb.base/relational.exp: print value of x>y<=z +PASS: gdb.base/relational.exp: print value of x>=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x>=y!=z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=y<=z +PASS: gdb.base/relational.exp: print value of x<=y==z +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: print value of x<=y!=z +PASS: gdb.base/relational.exp: print value of x==y!=z +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of x>=(y<z) +PASS: gdb.base/relational.exp: print value of x>=(y!=z) +PASS: gdb.base/relational.exp: print value of x==(y==z) +PASS: gdb.base/relational.exp: set variable x +PASS: gdb.base/relational.exp: set variable z +PASS: gdb.base/relational.exp: print value of (x==y)<z +Running ./gdb.base/relativedebug.exp ... +PASS: gdb.base/relativedebug.exp: continue +PASS: gdb.base/relativedebug.exp: pause found in backtrace +Running ./gdb.base/relocate.exp ... +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o 0 +PASS: gdb.base/relocate.exp: get address of static_foo +PASS: gdb.base/relocate.exp: get address of static_bar +PASS: gdb.base/relocate.exp: static variables have different addresses +PASS: gdb.base/relocate.exp: get address of global_foo +PASS: gdb.base/relocate.exp: get address of global_bar +PASS: gdb.base/relocate.exp: global variables have different addresses +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: get address of function_bar +PASS: gdb.base/relocate.exp: functions have different addresses +PASS: gdb.base/relocate.exp: set $offset = 0x10000 +PASS: gdb.base/relocate.exp: add-symbol-file relocate.o $offset +PASS: gdb.base/relocate.exp: get address of function_foo +PASS: gdb.base/relocate.exp: function foo has a different address +PASS: gdb.base/relocate.exp: print static_foo +PASS: gdb.base/relocate.exp: print static_bar +PASS: gdb.base/relocate.exp: print global_foo +PASS: gdb.base/relocate.exp: print global_bar +Running ./gdb.base/remote.exp ... +PASS: gdb.base/remote.exp: write-packet default +PASS: gdb.base/remote.exp: set write-packet - NULL +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 20 +PASS: gdb.base/remote.exp: set write-packet - small +PASS: gdb.base/remote.exp: set remote memory-write-packet-size 1 +PASS: gdb.base/remote.exp: set write-packet - very-small +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 398 +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 400 +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 0 - set write size class +PASS: gdb.base/remote.exp: timed download `remote' - fixed, 16385 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 - set packet size +PASS: gdb.base/remote.exp: timed download `remote' - limit, 0 +PASS: gdb.base/remote.exp: get integer valueof "sizeof (random_data)" (49152) +PASS: gdb.base/remote.exp: x/8ub random_data +PASS: gdb.base/remote.exp: x/8ub random_data + 400 - 4 +PASS: gdb.base/remote.exp: x/8ub random_data + 16384 - 4 +PASS: gdb.base/remote.exp: set remote memory-read-packet-size 16 +PASS: gdb.base/remote.exp: show remote memory-read-packet-size +PASS: gdb.base/remote.exp: x/17ub random_data +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit -1 +PASS: gdb.base/remote.exp: set remote hardware-watchpoint-limit 2147483647 +PASS: gdb.base/remote.exp: set remote hardware-breakpoint-limit 2147483647 +Running ./gdb.base/remotetimeout.exp ... +Running ./gdb.base/reread.exp ... +PASS: gdb.base/reread.exp: breakpoint foo in first file +PASS: gdb.base/reread.exp: run to foo() +UNSUPPORTED: gdb.base/reread.exp: run to foo() second time +UNSUPPORTED: gdb.base/reread.exp: second pass: GDB should check for changes before running +Running ./gdb.base/restore.exp ... +PASS: gdb.base/restore.exp: tbreak caller1 +PASS: gdb.base/restore.exp: run to caller1 +PASS: gdb.base/restore.exp: caller1 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller1 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller1 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller1 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller1 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: tbreak caller2 +PASS: gdb.base/restore.exp: run to caller2 +PASS: gdb.base/restore.exp: caller2 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller2 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller2 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller2 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller2 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller2 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: tbreak caller3 +PASS: gdb.base/restore.exp: run to caller3 +PASS: gdb.base/restore.exp: caller3 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller3 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller3 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller3 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller3 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: tbreak caller4 +PASS: gdb.base/restore.exp: run to caller4 +PASS: gdb.base/restore.exp: caller4 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee1; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee2; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee3; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee4; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller4 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller4 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller4 calls callee5; return callee now +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller4 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: tbreak caller5 +PASS: gdb.base/restore.exp: run to caller5 +PASS: gdb.base/restore.exp: caller5 calls callee1; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee1; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee1; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee1; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee1; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee2; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee2; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee2; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee2; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee2; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee3; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee3; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee3; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee3; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee3; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee4; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee4; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee4; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee4; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee4; return restored l5 to 32496 +PASS: gdb.base/restore.exp: caller5 calls callee5; tbreak callee +PASS: gdb.base/restore.exp: caller5 calls callee5; continue to callee +PASS: gdb.base/restore.exp: caller5 calls callee5; return callee now +FAIL: gdb.base/restore.exp: caller5 calls callee5; return restored l1 to 32492 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l2 to 32493 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l3 to 32494 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l4 to 32495 +PASS: gdb.base/restore.exp: caller5 calls callee5; return restored l5 to 32496 +Running ./gdb.base/return2.exp ... +PASS: gdb.base/return2.exp: set break on void_func +PASS: gdb.base/return2.exp: continue to void_func +PASS: gdb.base/return2.exp: return from void_func +PASS: gdb.base/return2.exp: void function returned successfully +PASS: gdb.base/return2.exp: set break on char_func +PASS: gdb.base/return2.exp: continue to char_func +PASS: gdb.base/return2.exp: return from char_func +PASS: gdb.base/return2.exp: char value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on short_func +PASS: gdb.base/return2.exp: continue to short_func +PASS: gdb.base/return2.exp: return from short_func +PASS: gdb.base/return2.exp: short value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on int_func +PASS: gdb.base/return2.exp: continue to int_func +PASS: gdb.base/return2.exp: return from int_func +PASS: gdb.base/return2.exp: int value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_func +PASS: gdb.base/return2.exp: continue to long_func +PASS: gdb.base/return2.exp: return from long_func +PASS: gdb.base/return2.exp: long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on long_long_func +PASS: gdb.base/return2.exp: continue to long_long_func +PASS: gdb.base/return2.exp: return from long_long_func +PASS: gdb.base/return2.exp: long_long value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on float_func +PASS: gdb.base/return2.exp: continue to float_func +PASS: gdb.base/return2.exp: return from float_func +PASS: gdb.base/return2.exp: float value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +PASS: gdb.base/return2.exp: set break on double_func +PASS: gdb.base/return2.exp: continue to double_func +PASS: gdb.base/return2.exp: return from double_func +PASS: gdb.base/return2.exp: double value returned successfully +PASS: gdb.base/return2.exp: validate result value not equal to program return value +Running ./gdb.base/return.exp ... +PASS: gdb.base/return.exp: simple return +PASS: gdb.base/return.exp: break func2 +PASS: gdb.base/return.exp: break func3 +PASS: gdb.base/return.exp: continue to return of -5 +PASS: gdb.base/return.exp: next over call to func2 +PASS: gdb.base/return.exp: correct value returned (integer test) +PASS: gdb.base/return.exp: continue to return of -5.0 +PASS: gdb.base/return.exp: next over call to func3 +PASS: gdb.base/return.exp: correct value returned double test (known problem with sparc solaris) +Running ./gdb.base/return-nodebug.exp ... +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: signed-char: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: signed-char: advance to marker +PASS: gdb.base/return-nodebug.exp: signed-char: full width of the returned result +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: short: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: short: advance to marker +PASS: gdb.base/return-nodebug.exp: short: full width of the returned result +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: int: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: int: advance to marker +PASS: gdb.base/return-nodebug.exp: int: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long: advance to marker +PASS: gdb.base/return-nodebug.exp: long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: long-long: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: long-long: advance to marker +PASS: gdb.base/return-nodebug.exp: long-long: full width of the returned result +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: float: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: float: advance to marker +PASS: gdb.base/return-nodebug.exp: float: full width of the returned result +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info without a cast +PASS: gdb.base/return-nodebug.exp: double: return from function with no debug info with a cast +PASS: gdb.base/return-nodebug.exp: double: advance to marker +PASS: gdb.base/return-nodebug.exp: double: full width of the returned result +Running ./gdb.base/save-bp.exp ... +PASS: gdb.base/save-bp.exp: add breakpoint commands +PASS: gdb.base/save-bp.exp: dprintf save-bp.c:33,"At foo entry\n" +PASS: gdb.base/save-bp.exp: save breakpoint bps +PASS: gdb.base/save-bp.exp: source bps +PASS: gdb.base/save-bp.exp: info break +Running ./gdb.base/savedregs.exp ... +PASS: gdb.base/savedregs.exp: advance thrower +PASS: gdb.base/savedregs.exp: Get main info frame +PASS: gdb.base/savedregs.exp: handle SIGSEGV pass print nostop +PASS: gdb.base/savedregs.exp: handle SIGILL pass print nostop +PASS: gdb.base/savedregs.exp: advance catcher +PASS: gdb.base/savedregs.exp: Get sigtramp info frame +PASS: gdb.base/savedregs.exp: Get thrower info frame +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: break caller +PASS: gdb.base/savedregs.exp: call caller (1,2,3,4,5,6,7,8) +PASS: gdb.base/savedregs.exp: Get dummy info frame +PASS: gdb.base/savedregs.exp: Get catcher info frame +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: advance callee +PASS: gdb.base/savedregs.exp: Get caller info frame +PASS: gdb.base/savedregs.exp: Check dummy info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check catcher info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check sigtramp info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check thrower info frame; stack contains callee caller dummy catcher sigtramp thrower main +PASS: gdb.base/savedregs.exp: Check main info frame; stack contains callee caller dummy catcher sigtramp thrower main +Running ./gdb.base/scope.exp ... +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +UNSUPPORTED: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss before run +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal before run +PASS: gdb.base/scope.exp: next over init0() in main +PASS: gdb.base/scope.exp: print filelocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at main +PASS: gdb.base/scope.exp: print filelocal_bss +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_main +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_main +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro +PASS: gdb.base/scope.exp: print foo::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal +PASS: gdb.base/scope.exp: print foo::funclocal_ro +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro +PASS: gdb.base/scope.exp: print bar::funclocal +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro +PASS: gdb.base/scope.exp: print filelocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at foo +PASS: gdb.base/scope.exp: print filelocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at foo +PASS: gdb.base/scope.exp: print filelocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at foo +PASS: gdb.base/scope.exp: print funclocal at foo +PASS: gdb.base/scope.exp: print foo::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at foo +PASS: gdb.base/scope.exp: print funclocal_bss at foo +PASS: gdb.base/scope.exp: print foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at foo +PASS: gdb.base/scope.exp: print funclocal_ro at foo +PASS: gdb.base/scope.exp: print foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at foo +PASS: gdb.base/scope.exp: print bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at foo +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal at bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_bss in test_at_bar +PASS: gdb.base/scope.exp: print 'scope0.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print filelocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal at bar +PASS: gdb.base/scope.exp: print filelocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_bss at bar +PASS: gdb.base/scope.exp: print filelocal_ro in test_at_bar +PASS: gdb.base/scope.exp: print 'scope1.c'::filelocal_ro at bar +PASS: gdb.base/scope.exp: print foo::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal at bar +PASS: gdb.base/scope.exp: print foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_bss at bar +PASS: gdb.base/scope.exp: print foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::foo::funclocal_ro at bar +PASS: gdb.base/scope.exp: print funclocal at bar +PASS: gdb.base/scope.exp: print bar::funclocal at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal at bar +PASS: gdb.base/scope.exp: print funclocal_bss at bar +PASS: gdb.base/scope.exp: print bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: print 'scope1.c'::bar::funclocal_bss at bar +PASS: gdb.base/scope.exp: continue to marker2 +PASS: gdb.base/scope.exp: up from marker2 in scopes.exp +PASS: gdb.base/scope.exp: print localval, outer scope +PASS: gdb.base/scope.exp: print localval1, outer scope +PASS: gdb.base/scope.exp: print localval2, outer scope +PASS: gdb.base/scope.exp: print localval3, outer scope +PASS: gdb.base/scope.exp: continue to marker3 in scope.exp +PASS: gdb.base/scope.exp: up from marker3 in scope.exp +PASS: gdb.base/scope.exp: print localval, first nested scope +PASS: gdb.base/scope.exp: print localval1, first nested scope +PASS: gdb.base/scope.exp: print localval2, first nested scope +PASS: gdb.base/scope.exp: print localval3, first nested scope +PASS: gdb.base/scope.exp: continue to marker4 in scope.exp +PASS: gdb.base/scope.exp: up from marker4 in scope.exp +PASS: gdb.base/scope.exp: print localval, innermost scope +PASS: gdb.base/scope.exp: print localval1, innermost scope +PASS: gdb.base/scope.exp: print localval2, innermost scope +PASS: gdb.base/scope.exp: print localval3, innermost scope +PASS: gdb.base/scope.exp: continue to marker1 +PASS: gdb.base/scope.exp: up from marker1 in scope.exp +PASS: gdb.base/scope.exp: 100 auto variables correctly initialized +PASS: gdb.base/scope.exp: args in correct order +Running ./gdb.base/sect-cmd.exp ... +Running ./gdb.base/sepdebug.exp ... +PASS: gdb.base/sepdebug.exp: breakpoint function +PASS: gdb.base/sepdebug.exp: breakpoint quoted function +PASS: gdb.base/sepdebug.exp: breakpoint function in file +PASS: gdb.base/sepdebug.exp: use `list' to establish default source file +PASS: gdb.base/sepdebug.exp: breakpoint line number +PASS: gdb.base/sepdebug.exp: breakpoint duplicate +PASS: gdb.base/sepdebug.exp: breakpoint line number in file +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line if conditional +PASS: gdb.base/sepdebug.exp: breakpoint at start of multi line while conditional +PASS: gdb.base/sepdebug.exp: breakpoint info +PASS: gdb.base/sepdebug.exp: run until function breakpoint +PASS: gdb.base/sepdebug.exp: run until breakpoint set at a line number +PASS: gdb.base/sepdebug.exp: run until file:function(6) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(5) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(4) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(3) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(2) breakpoint +PASS: gdb.base/sepdebug.exp: run until file:function(1) breakpoint +PASS: gdb.base/sepdebug.exp: run until quoted breakpoint +PASS: gdb.base/sepdebug.exp: run until file:linenum breakpoint +PASS: gdb.base/sepdebug.exp: breakpoint offset +1 +PASS: gdb.base/sepdebug.exp: step onto breakpoint +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function +PASS: gdb.base/sepdebug.exp: Temporary breakpoint function in file +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number #2 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #1 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint line number in file #2 +PASS: gdb.base/sepdebug.exp: Temporary breakpoint info +PASS: gdb.base/sepdebug.exp: catch requires an event name +PASS: gdb.base/sepdebug.exp: set catch fork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch vfork, never expected to trigger +PASS: gdb.base/sepdebug.exp: set catch exec, never expected to trigger +PASS: gdb.base/sepdebug.exp: set breakpoint pending off +PASS: gdb.base/sepdebug.exp: break on non-existent source line +PASS: gdb.base/sepdebug.exp: until bp_location1 +PASS: gdb.base/sepdebug.exp: break on default location, 1st time +PASS: gdb.base/sepdebug.exp: break on default location, 2nd time +PASS: gdb.base/sepdebug.exp: break on default location, 3rd time +PASS: gdb.base/sepdebug.exp: break on default location, 4th time +PASS: gdb.base/sepdebug.exp: set to-be-silent break bp_location1 +PASS: gdb.base/sepdebug.exp: set silent break bp_location1 +PASS: gdb.base/sepdebug.exp: info silent break bp_location1 +PASS: gdb.base/sepdebug.exp: hit silent break bp_location1 +PASS: gdb.base/sepdebug.exp: stopped for silent break bp_location1 +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on non-existent thread disallowed +PASS: gdb.base/sepdebug.exp: thread-specific breakpoint on bogus thread ID disallowed +PASS: gdb.base/sepdebug.exp: breakpoint with trailing garbage disallowed +PASS: gdb.base/sepdebug.exp: step over breakpoint +PASS: gdb.base/sepdebug.exp: clear line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: clear current line has no breakpoint disallowed +PASS: gdb.base/sepdebug.exp: break marker3 #1 +PASS: gdb.base/sepdebug.exp: break marker3 #2 +PASS: gdb.base/sepdebug.exp: clear marker3 +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to bp_location11 +PASS: gdb.base/sepdebug.exp: set breakpoint via convenience variable +PASS: gdb.base/sepdebug.exp: set convenience variable $foo to 81.5 +PASS: gdb.base/sepdebug.exp: set breakpoint via non-integer convenience variable disallowed +PASS: gdb.base/sepdebug.exp: set breakpoint on to-be-called function +PASS: gdb.base/sepdebug.exp: hit breakpoint on called function +PASS: gdb.base/sepdebug.exp: backtrace while in called function +PASS: gdb.base/sepdebug.exp: finish from called function +PASS: gdb.base/sepdebug.exp: finish with arguments disallowed +PASS: gdb.base/sepdebug.exp: finish from outermost frame disallowed +PASS: gdb.base/sepdebug.exp: kill program +PASS: gdb.base/sepdebug.exp: break at factorial +PASS: gdb.base/sepdebug.exp: continue to factorial(5) +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5) +PASS: gdb.base/sepdebug.exp: next to recursive call +PASS: gdb.base/sepdebug.exp: next over recursive call +PASS: gdb.base/sepdebug.exp: backtrace from factorial(5.1) +PASS: gdb.base/sepdebug.exp: continue until exit at recursive next test +PASS: gdb.base/sepdebug.exp: debuglink: set separate debug location +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: debuglink: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: CRC mismatch is reported +PASS: gdb.base/sepdebug.exp: build-id support by binutils +PASS: gdb.base/sepdebug.exp: build-id: set separate debug location +PASS: gdb.base/sepdebug.exp: build-id: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: build-id: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: build-id: run until breakpoint set at small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: set separate debug location +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: breakpoint small function, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until function breakpoint, optimized file +PASS: gdb.base/sepdebug.exp: multiple-dirs: run until breakpoint set at small function, optimized file +Running ./gdb.base/sep.exp ... +PASS: gdb.base/sep.exp: list using location inside included file +PASS: gdb.base/sep.exp: breakpoint inside included file +Running ./gdb.base/sepsymtab.exp ... +PASS: gdb.base/sepsymtab.exp: info sym main +Running ./gdb.base/set-lang-auto.exp ... +PASS: gdb.base/set-lang-auto.exp: show lang after loading binary +PASS: gdb.base/set-lang-auto.exp: forcing the language to ada +PASS: gdb.base/set-lang-auto.exp: show lang after switching language to ada +PASS: gdb.base/set-lang-auto.exp: switching the language back to auto +PASS: gdb.base/set-lang-auto.exp: show lang after having switched back to auto +Running ./gdb.base/set-noassign.exp ... +PASS: gdb.base/set-noassign.exp: set language ada +PASS: gdb.base/set-noassign.exp: warning for set without assignment +Running ./gdb.base/setshow.exp ... +PASS: gdb.base/setshow.exp: default annotation_level is zero +PASS: gdb.base/setshow.exp: set annotate 2 +PASS: gdb.base/setshow.exp: show annotate 2 +PASS: gdb.base/setshow.exp: annotation_level 2 +PASS: gdb.base/setshow.exp: set annotate 1 +PASS: gdb.base/setshow.exp: show annotate (1) +PASS: gdb.base/setshow.exp: annotation_level 1 +PASS: gdb.base/setshow.exp: set annotate 0 +PASS: gdb.base/setshow.exp: show annotate (0) +PASS: gdb.base/setshow.exp: annotation_level 0 +PASS: gdb.base/setshow.exp: set args ~ +PASS: gdb.base/setshow.exp: show args ~ +PASS: gdb.base/setshow.exp: set args +PASS: gdb.base/setshow.exp: show args +PASS: gdb.base/setshow.exp: set check range on +PASS: gdb.base/setshow.exp: show check range (on) +PASS: gdb.base/setshow.exp: set check range off +PASS: gdb.base/setshow.exp: show check range (off) +PASS: gdb.base/setshow.exp: set check range auto +PASS: gdb.base/setshow.exp: show check range (auto) +PASS: gdb.base/setshow.exp: set check type on +PASS: gdb.base/setshow.exp: show check type (on) +PASS: gdb.base/setshow.exp: set check type off +PASS: gdb.base/setshow.exp: show check type (off) +PASS: gdb.base/setshow.exp: set complaints 100 +PASS: gdb.base/setshow.exp: show complaints (100) +PASS: gdb.base/setshow.exp: set complaints 0 +PASS: gdb.base/setshow.exp: show complaints (0) +PASS: gdb.base/setshow.exp: set confirm off +PASS: gdb.base/setshow.exp: show confirm (off) +PASS: gdb.base/setshow.exp: set confirm on +PASS: gdb.base/setshow.exp: show confirm (on) +PASS: gdb.base/setshow.exp: set editing off +PASS: gdb.base/setshow.exp: show editing (off) +PASS: gdb.base/setshow.exp: set environment FOOBARBAZ +PASS: gdb.base/setshow.exp: show environment FOOBARBAZ +PASS: gdb.base/setshow.exp: set height 100 +PASS: gdb.base/setshow.exp: show height +PASS: gdb.base/setshow.exp: set history expansion on +PASS: gdb.base/setshow.exp: show history expansion +PASS: gdb.base/setshow.exp: set history filename foobar.baz +PASS: gdb.base/setshow.exp: show history filename (foobar.baz) +PASS: gdb.base/setshow.exp: set history save on +PASS: gdb.base/setshow.exp: show history save (on) +PASS: gdb.base/setshow.exp: set history size 100 +PASS: gdb.base/setshow.exp: show history size (100) +PASS: gdb.base/setshow.exp: set language asm +PASS: gdb.base/setshow.exp: show language (asm) +PASS: gdb.base/setshow.exp: set language java +PASS: gdb.base/setshow.exp: show language (java) +PASS: gdb.base/setshow.exp: complete set language minimal +PASS: gdb.base/setshow.exp: set language auto +PASS: gdb.base/setshow.exp: show language (auto) +PASS: gdb.base/setshow.exp: set listsize 100 +PASS: gdb.base/setshow.exp: show listsize (100) +PASS: gdb.base/setshow.exp: set prompt FooBarBaz +PASS: gdb.base/setshow.exp: show prompt FooBarBaz +PASS: gdb.base/setshow.exp: set prompt gdb +PASS: gdb.base/setshow.exp: set radix 11 +PASS: gdb.base/setshow.exp: set radix 16 +PASS: gdb.base/setshow.exp: show radix (16) +PASS: gdb.base/setshow.exp: set radix 10 +PASS: gdb.base/setshow.exp: show radix (10) +PASS: gdb.base/setshow.exp: set width 90 +PASS: gdb.base/setshow.exp: show width (90) +PASS: gdb.base/setshow.exp: set write on +PASS: gdb.base/setshow.exp: show write (on) +PASS: gdb.base/setshow.exp: show user +PASS: gdb.base/setshow.exp: set verbose on +PASS: gdb.base/setshow.exp: show verbose (on) +PASS: gdb.base/setshow.exp: set verbose off +PASS: gdb.base/setshow.exp: show verbose (off) +Running ./gdb.base/setvar.exp ... +PASS: gdb.base/setvar.exp: set print sevenbit-strings +PASS: gdb.base/setvar.exp: set variable char=0 +PASS: gdb.base/setvar.exp: set variable char=1 +PASS: gdb.base/setvar.exp: set variable char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable char=65 ('A') +PASS: gdb.base/setvar.exp: set variable char=97 ('a') +PASS: gdb.base/setvar.exp: set variable char=126 ('~') +PASS: gdb.base/setvar.exp: set variable char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable signed char=0 +PASS: gdb.base/setvar.exp: set variable signed char=1 +PASS: gdb.base/setvar.exp: set variable signed char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable signed char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable signed char=65 ('A') +PASS: gdb.base/setvar.exp: set variable signed char=97 ('a') +PASS: gdb.base/setvar.exp: set variable signed char=126 ('~') +PASS: gdb.base/setvar.exp: set variable signed char=127 (8-bit) +PASS: gdb.base/setvar.exp: set variable v_signed_char=-1 +PASS: gdb.base/setvar.exp: set variable signed char=-1 (-1) +PASS: gdb.base/setvar.exp: set variable v_signed_char=0xFF +PASS: gdb.base/setvar.exp: set variable signed char=0xFF (0xFF) +PASS: gdb.base/setvar.exp: set variable unsigned char=0 +PASS: gdb.base/setvar.exp: set variable unsigned char=1 +PASS: gdb.base/setvar.exp: set variable unsigned char=7 (Bel) +PASS: gdb.base/setvar.exp: set variable unsigned char=32 (SPC) +PASS: gdb.base/setvar.exp: set variable unsigned char=65 ('A') +PASS: gdb.base/setvar.exp: set variable unsigned char=97 ('a') +PASS: gdb.base/setvar.exp: set variable unsigned char=126 ('~') +PASS: gdb.base/setvar.exp: set variable unsigned char=255 (8-bit) +PASS: gdb.base/setvar.exp: set variable short=0 +PASS: gdb.base/setvar.exp: set variable short=1 +PASS: gdb.base/setvar.exp: set variable short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed short=0 +PASS: gdb.base/setvar.exp: set variable signed short=1 +PASS: gdb.base/setvar.exp: set variable signed short=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned short=0 +PASS: gdb.base/setvar.exp: set variable unsigned short=1 +PASS: gdb.base/setvar.exp: set variable unsigned short=~0 (minus) +PASS: gdb.base/setvar.exp: set variable int=0 +PASS: gdb.base/setvar.exp: set variable int=1 +PASS: gdb.base/setvar.exp: set variable int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed int=0 +PASS: gdb.base/setvar.exp: set variable signed int=1 +PASS: gdb.base/setvar.exp: set variable signed int=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned int=0 +PASS: gdb.base/setvar.exp: set variable unsigned int=1 +PASS: gdb.base/setvar.exp: set variable unsigned int=~0 (minus) +PASS: gdb.base/setvar.exp: set variable long=0 +PASS: gdb.base/setvar.exp: set variable long=1 +PASS: gdb.base/setvar.exp: set variable long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable signed long=0 +PASS: gdb.base/setvar.exp: set variable signed long=1 +PASS: gdb.base/setvar.exp: set variable signed long=-1 (minus) +PASS: gdb.base/setvar.exp: set variable unsigned long=0 +PASS: gdb.base/setvar.exp: set variable unsigned long=1 +PASS: gdb.base/setvar.exp: set variable unsigned long=~0 (minus) +PASS: gdb.base/setvar.exp: set variable float=0 +PASS: gdb.base/setvar.exp: set variable float=1 +PASS: gdb.base/setvar.exp: set variable float=-1 (minus) +PASS: gdb.base/setvar.exp: set variable double=0 +PASS: gdb.base/setvar.exp: set variable double=1 +PASS: gdb.base/setvar.exp: set variable double=-1 (minus) +PASS: gdb.base/setvar.exp: set variable char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char array="hi" (string) +PASS: gdb.base/setvar.exp: set variable short array +PASS: gdb.base/setvar.exp: set variable signed short array +PASS: gdb.base/setvar.exp: set variable unsigned short array +PASS: gdb.base/setvar.exp: set variable int array +PASS: gdb.base/setvar.exp: set variable signed int array +PASS: gdb.base/setvar.exp: set variable unsigned int array +PASS: gdb.base/setvar.exp: set variable long array +PASS: gdb.base/setvar.exp: set variable signed long array +PASS: gdb.base/setvar.exp: set variable unsigned long array +PASS: gdb.base/setvar.exp: set variable float array +PASS: gdb.base/setvar.exp: set variable double array +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable signed char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) +PASS: gdb.base/setvar.exp: set variable unsigned char pointer="hi" (string) (#2) +PASS: gdb.base/setvar.exp: set variable short pointer +PASS: gdb.base/setvar.exp: set variable short pointer (#2) +PASS: gdb.base/setvar.exp: set v_signed_short_pointer=v_signed_short_array +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_signed_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable signed short pointer +PASS: gdb.base/setvar.exp: print *(v_signed_short_pointer+1) +PASS: gdb.base/setvar.exp: set v_unsigned_short_pointer=v_unsigned_short_array +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer)=123 +PASS: gdb.base/setvar.exp: set variable *(v_unsigned_short_pointer+1)=-456 +PASS: gdb.base/setvar.exp: set variable unsigned short pointer +PASS: gdb.base/setvar.exp: print *(v_unsigned_short_pointer+1) +PASS: gdb.base/setvar.exp: set variable int pointer +PASS: gdb.base/setvar.exp: set variable int pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed int pointer +PASS: gdb.base/setvar.exp: set variable signed int pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned int pointer +PASS: gdb.base/setvar.exp: print variable unsigned int pointer+1 +PASS: gdb.base/setvar.exp: set variable long pointer +PASS: gdb.base/setvar.exp: set variable long pointer (#2) +PASS: gdb.base/setvar.exp: set variable signed long pointer +PASS: gdb.base/setvar.exp: set variable signed long pointer (#2) +PASS: gdb.base/setvar.exp: set variable unsigned long pointer +PASS: gdb.base/setvar.exp: set variable unsigned long pointer (#2) +PASS: gdb.base/setvar.exp: set variable float pointer +PASS: gdb.base/setvar.exp: set variable float pointer (#2) +PASS: gdb.base/setvar.exp: set variable double pointer +PASS: gdb.base/setvar.exp: set variable double pointer (#2) +PASS: gdb.base/setvar.exp: set variable structure char member +PASS: gdb.base/setvar.exp: set variable structure short member +PASS: gdb.base/setvar.exp: set variable structure int member +PASS: gdb.base/setvar.exp: set variable structure long member +PASS: gdb.base/setvar.exp: set variable structure float member +PASS: gdb.base/setvar.exp: set variable structure double member +PASS: gdb.base/setvar.exp: set print structure #1 +PASS: gdb.base/setvar.exp: set print structure #2 +PASS: gdb.base/setvar.exp: set print structure #3 +PASS: gdb.base/setvar.exp: set print structure #4 +PASS: gdb.base/setvar.exp: print sef.field=sm1 +PASS: gdb.base/setvar.exp: print sef.field (sm1) +PASS: gdb.base/setvar.exp: print sef.field=s1 +PASS: gdb.base/setvar.exp: print sef.field (s1) +PASS: gdb.base/setvar.exp: print uef.field=u2 +PASS: gdb.base/setvar.exp: print uef.field (u2) +PASS: gdb.base/setvar.exp: print uef.field=u1 +PASS: gdb.base/setvar.exp: print uef.field (u1) +PASS: gdb.base/setvar.exp: print sef.field=7 +PASS: gdb.base/setvar.exp: print uef.field=6 +Running ./gdb.base/shell.exp ... +PASS: gdb.base/shell.exp: shell echo foo +PASS: gdb.base/shell.exp: ! echo foo +PASS: gdb.base/shell.exp: !echo foo +Running ./gdb.base/shlib-call.exp ... +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +PASS: gdb.base/shlib-call.exp: next to shr1 +PASS: gdb.base/shlib-call.exp: print g +PASS: gdb.base/shlib-call.exp: print g +PASS: gdb.base/shlib-call.exp: breakpoint function shr2 +PASS: gdb.base/shlib-call.exp: run until breakpoint set at a function +PASS: gdb.base/shlib-call.exp: print mainshr1(1) from shlib func +PASS: gdb.base/shlib-call.exp: step out of shr2 to main (stopped in shr2 epilogue) +PASS: gdb.base/shlib-call.exp: step out of shr2 epilogue to main +PASS: gdb.base/shlib-call.exp: print mainshr1(1) +PASS: gdb.base/shlib-call.exp: step into mainshr1 +PASS: gdb.base/shlib-call.exp: set print sevenbit-strings +PASS: gdb.base/shlib-call.exp: set print address off +PASS: gdb.base/shlib-call.exp: set width 0 +Running ./gdb.base/shreloc.exp ... +PASS: gdb.base/shreloc.exp: get address of fn_1 +PASS: gdb.base/shreloc.exp: get address of fn_2 +PASS: gdb.base/shreloc.exp: relocated extern functions have different addresses +PASS: gdb.base/shreloc.exp: get address of extern_var_1 +PASS: gdb.base/shreloc.exp: get address of extern_var_2 +PASS: gdb.base/shreloc.exp: relocated extern variables have different addresses +PASS: gdb.base/shreloc.exp: get address of static_var_1 +PASS: gdb.base/shreloc.exp: get address of static_var_2 +PASS: gdb.base/shreloc.exp: relocated static variables have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs static_var_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated static vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs extern_var_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated extern vars have different addresses +PASS: gdb.base/shreloc.exp: get_msym_addrs fn_[12] +PASS: gdb.base/shreloc.exp: (msymbol) relocated functions have different addresses +Running ./gdb.base/sigall.exp ... +PASS: gdb.base/sigall.exp: handle SIGABRT stop print +PASS: gdb.base/sigall.exp: b handle_ABRT +PASS: gdb.base/sigall.exp: b gen_HUP +PASS: gdb.base/sigall.exp: get signal ABRT +PASS: gdb.base/sigall.exp: send signal ABRT +PASS: gdb.base/sigall.exp: advance to HUP +PASS: gdb.base/sigall.exp: handle SIGHUP stop print +PASS: gdb.base/sigall.exp: b handle_HUP +PASS: gdb.base/sigall.exp: b gen_QUIT +PASS: gdb.base/sigall.exp: get signal HUP +PASS: gdb.base/sigall.exp: send signal HUP +PASS: gdb.base/sigall.exp: advance to QUIT +PASS: gdb.base/sigall.exp: handle SIGQUIT stop print +PASS: gdb.base/sigall.exp: b handle_QUIT +PASS: gdb.base/sigall.exp: b gen_ILL +PASS: gdb.base/sigall.exp: get signal QUIT +PASS: gdb.base/sigall.exp: send signal QUIT +PASS: gdb.base/sigall.exp: advance to ILL +PASS: gdb.base/sigall.exp: handle SIGILL stop print +PASS: gdb.base/sigall.exp: b handle_ILL +PASS: gdb.base/sigall.exp: b gen_EMT +PASS: gdb.base/sigall.exp: get signal ILL +PASS: gdb.base/sigall.exp: send signal ILL +PASS: gdb.base/sigall.exp: advance to EMT +PASS: gdb.base/sigall.exp: handle SIGEMT stop print +PASS: gdb.base/sigall.exp: b handle_EMT +PASS: gdb.base/sigall.exp: b gen_FPE +PASS: gdb.base/sigall.exp: send signal EMT +PASS: gdb.base/sigall.exp: advance to FPE +PASS: gdb.base/sigall.exp: handle SIGFPE stop print +PASS: gdb.base/sigall.exp: b handle_FPE +PASS: gdb.base/sigall.exp: b gen_BUS +PASS: gdb.base/sigall.exp: get signal FPE +PASS: gdb.base/sigall.exp: send signal FPE +PASS: gdb.base/sigall.exp: advance to BUS +PASS: gdb.base/sigall.exp: handle SIGBUS stop print +PASS: gdb.base/sigall.exp: b handle_BUS +PASS: gdb.base/sigall.exp: b gen_SEGV +PASS: gdb.base/sigall.exp: get signal BUS +PASS: gdb.base/sigall.exp: send signal BUS +PASS: gdb.base/sigall.exp: advance to SEGV +PASS: gdb.base/sigall.exp: handle SIGSEGV stop print +PASS: gdb.base/sigall.exp: b handle_SEGV +PASS: gdb.base/sigall.exp: b gen_SYS +PASS: gdb.base/sigall.exp: get signal SEGV +PASS: gdb.base/sigall.exp: send signal SEGV +PASS: gdb.base/sigall.exp: advance to SYS +PASS: gdb.base/sigall.exp: handle SIGSYS stop print +PASS: gdb.base/sigall.exp: b handle_SYS +PASS: gdb.base/sigall.exp: b gen_PIPE +PASS: gdb.base/sigall.exp: get signal SYS +PASS: gdb.base/sigall.exp: send signal SYS +PASS: gdb.base/sigall.exp: advance to PIPE +PASS: gdb.base/sigall.exp: handle SIGPIPE stop print +PASS: gdb.base/sigall.exp: b handle_PIPE +PASS: gdb.base/sigall.exp: b gen_ALRM +PASS: gdb.base/sigall.exp: get signal PIPE +PASS: gdb.base/sigall.exp: send signal PIPE +PASS: gdb.base/sigall.exp: advance to ALRM +PASS: gdb.base/sigall.exp: handle SIGALRM stop print +PASS: gdb.base/sigall.exp: b handle_ALRM +PASS: gdb.base/sigall.exp: b gen_URG +PASS: gdb.base/sigall.exp: get signal ALRM +PASS: gdb.base/sigall.exp: send signal ALRM +PASS: gdb.base/sigall.exp: advance to URG +PASS: gdb.base/sigall.exp: handle SIGURG stop print +PASS: gdb.base/sigall.exp: b handle_URG +PASS: gdb.base/sigall.exp: b gen_TSTP +PASS: gdb.base/sigall.exp: get signal URG +PASS: gdb.base/sigall.exp: send signal URG +PASS: gdb.base/sigall.exp: advance to TSTP +PASS: gdb.base/sigall.exp: handle SIGTSTP stop print +PASS: gdb.base/sigall.exp: b handle_TSTP +PASS: gdb.base/sigall.exp: b gen_CONT +PASS: gdb.base/sigall.exp: get signal TSTP +PASS: gdb.base/sigall.exp: send signal TSTP +PASS: gdb.base/sigall.exp: advance to CONT +PASS: gdb.base/sigall.exp: handle SIGCONT stop print +PASS: gdb.base/sigall.exp: b handle_CONT +PASS: gdb.base/sigall.exp: b gen_CHLD +PASS: gdb.base/sigall.exp: get signal CONT +PASS: gdb.base/sigall.exp: send signal CONT +PASS: gdb.base/sigall.exp: advance to CHLD +PASS: gdb.base/sigall.exp: handle SIGCHLD stop print +PASS: gdb.base/sigall.exp: b handle_CHLD +PASS: gdb.base/sigall.exp: b gen_TTIN +PASS: gdb.base/sigall.exp: get signal CHLD +PASS: gdb.base/sigall.exp: send signal CHLD +PASS: gdb.base/sigall.exp: advance to TTIN +PASS: gdb.base/sigall.exp: handle SIGTTIN stop print +PASS: gdb.base/sigall.exp: b handle_TTIN +PASS: gdb.base/sigall.exp: b gen_TTOU +PASS: gdb.base/sigall.exp: get signal TTIN +PASS: gdb.base/sigall.exp: send signal TTIN +PASS: gdb.base/sigall.exp: advance to TTOU +PASS: gdb.base/sigall.exp: handle SIGTTOU stop print +PASS: gdb.base/sigall.exp: b handle_TTOU +PASS: gdb.base/sigall.exp: b gen_IO +PASS: gdb.base/sigall.exp: get signal TTOU +PASS: gdb.base/sigall.exp: send signal TTOU +PASS: gdb.base/sigall.exp: advance to IO +PASS: gdb.base/sigall.exp: handle SIGIO stop print +PASS: gdb.base/sigall.exp: b handle_IO +PASS: gdb.base/sigall.exp: b gen_XCPU +PASS: gdb.base/sigall.exp: get signal IO +PASS: gdb.base/sigall.exp: send signal IO +PASS: gdb.base/sigall.exp: advance to XCPU +PASS: gdb.base/sigall.exp: handle SIGXCPU stop print +PASS: gdb.base/sigall.exp: b handle_XCPU +PASS: gdb.base/sigall.exp: b gen_XFSZ +PASS: gdb.base/sigall.exp: get signal XCPU +PASS: gdb.base/sigall.exp: send signal XCPU +PASS: gdb.base/sigall.exp: advance to XFSZ +PASS: gdb.base/sigall.exp: handle SIGXFSZ stop print +PASS: gdb.base/sigall.exp: b handle_XFSZ +PASS: gdb.base/sigall.exp: b gen_VTALRM +PASS: gdb.base/sigall.exp: get signal XFSZ +PASS: gdb.base/sigall.exp: send signal XFSZ +PASS: gdb.base/sigall.exp: advance to VTALRM +PASS: gdb.base/sigall.exp: handle SIGVTALRM stop print +PASS: gdb.base/sigall.exp: b handle_VTALRM +PASS: gdb.base/sigall.exp: b gen_PROF +PASS: gdb.base/sigall.exp: get signal VTALRM +PASS: gdb.base/sigall.exp: send signal VTALRM +PASS: gdb.base/sigall.exp: advance to PROF +PASS: gdb.base/sigall.exp: handle SIGPROF stop print +PASS: gdb.base/sigall.exp: b handle_PROF +PASS: gdb.base/sigall.exp: b gen_WINCH +PASS: gdb.base/sigall.exp: get signal PROF +PASS: gdb.base/sigall.exp: send signal PROF +PASS: gdb.base/sigall.exp: advance to WINCH +PASS: gdb.base/sigall.exp: handle SIGWINCH stop print +PASS: gdb.base/sigall.exp: b handle_WINCH +PASS: gdb.base/sigall.exp: b gen_LOST +PASS: gdb.base/sigall.exp: get signal WINCH +PASS: gdb.base/sigall.exp: send signal WINCH +PASS: gdb.base/sigall.exp: advance to LOST +PASS: gdb.base/sigall.exp: handle SIGLOST stop print +PASS: gdb.base/sigall.exp: b handle_LOST +PASS: gdb.base/sigall.exp: b gen_USR1 +PASS: gdb.base/sigall.exp: send signal LOST +PASS: gdb.base/sigall.exp: advance to USR1 +PASS: gdb.base/sigall.exp: handle SIGUSR1 stop print +PASS: gdb.base/sigall.exp: b handle_USR1 +PASS: gdb.base/sigall.exp: b gen_USR2 +PASS: gdb.base/sigall.exp: get signal USR1 +PASS: gdb.base/sigall.exp: send signal USR1 +PASS: gdb.base/sigall.exp: advance to USR2 +PASS: gdb.base/sigall.exp: handle SIGUSR2 stop print +PASS: gdb.base/sigall.exp: b handle_USR2 +PASS: gdb.base/sigall.exp: b gen_PWR +PASS: gdb.base/sigall.exp: get signal USR2 +PASS: gdb.base/sigall.exp: send signal USR2 +PASS: gdb.base/sigall.exp: advance to PWR +PASS: gdb.base/sigall.exp: handle SIGPWR stop print +PASS: gdb.base/sigall.exp: b handle_PWR +PASS: gdb.base/sigall.exp: b gen_POLL +PASS: gdb.base/sigall.exp: get signal PWR +PASS: gdb.base/sigall.exp: send signal PWR +PASS: gdb.base/sigall.exp: advance to POLL +PASS: gdb.base/sigall.exp: handle SIGPOLL stop print +PASS: gdb.base/sigall.exp: b handle_POLL +PASS: gdb.base/sigall.exp: b gen_WIND +PASS: gdb.base/sigall.exp: send signal POLL +PASS: gdb.base/sigall.exp: advance to WIND +PASS: gdb.base/sigall.exp: handle SIGWIND stop print +PASS: gdb.base/sigall.exp: b handle_WIND +PASS: gdb.base/sigall.exp: b gen_PHONE +PASS: gdb.base/sigall.exp: send signal WIND +PASS: gdb.base/sigall.exp: advance to PHONE +PASS: gdb.base/sigall.exp: handle SIGPHONE stop print +PASS: gdb.base/sigall.exp: b handle_PHONE +PASS: gdb.base/sigall.exp: b gen_WAITING +PASS: gdb.base/sigall.exp: send signal PHONE +PASS: gdb.base/sigall.exp: advance to WAITING +PASS: gdb.base/sigall.exp: handle SIGWAITING stop print +PASS: gdb.base/sigall.exp: b handle_WAITING +PASS: gdb.base/sigall.exp: b gen_LWP +PASS: gdb.base/sigall.exp: send signal WAITING +PASS: gdb.base/sigall.exp: advance to LWP +PASS: gdb.base/sigall.exp: handle SIGLWP stop print +PASS: gdb.base/sigall.exp: b handle_LWP +PASS: gdb.base/sigall.exp: b gen_DANGER +PASS: gdb.base/sigall.exp: send signal LWP +PASS: gdb.base/sigall.exp: advance to DANGER +PASS: gdb.base/sigall.exp: handle SIGDANGER stop print +PASS: gdb.base/sigall.exp: b handle_DANGER +PASS: gdb.base/sigall.exp: b gen_GRANT +PASS: gdb.base/sigall.exp: send signal DANGER +PASS: gdb.base/sigall.exp: advance to GRANT +PASS: gdb.base/sigall.exp: handle SIGGRANT stop print +PASS: gdb.base/sigall.exp: b handle_GRANT +PASS: gdb.base/sigall.exp: b gen_RETRACT +PASS: gdb.base/sigall.exp: send signal GRANT +PASS: gdb.base/sigall.exp: advance to RETRACT +PASS: gdb.base/sigall.exp: handle SIGRETRACT stop print +PASS: gdb.base/sigall.exp: b handle_RETRACT +PASS: gdb.base/sigall.exp: b gen_MSG +PASS: gdb.base/sigall.exp: send signal RETRACT +PASS: gdb.base/sigall.exp: advance to MSG +PASS: gdb.base/sigall.exp: handle SIGMSG stop print +PASS: gdb.base/sigall.exp: b handle_MSG +PASS: gdb.base/sigall.exp: b gen_SOUND +PASS: gdb.base/sigall.exp: send signal MSG +PASS: gdb.base/sigall.exp: advance to SOUND +PASS: gdb.base/sigall.exp: handle SIGSOUND stop print +PASS: gdb.base/sigall.exp: b handle_SOUND +PASS: gdb.base/sigall.exp: b gen_SAK +PASS: gdb.base/sigall.exp: send signal SOUND +PASS: gdb.base/sigall.exp: advance to SAK +PASS: gdb.base/sigall.exp: handle SIGSAK stop print +PASS: gdb.base/sigall.exp: b handle_SAK +PASS: gdb.base/sigall.exp: b gen_PRIO +PASS: gdb.base/sigall.exp: send signal SAK +PASS: gdb.base/sigall.exp: advance to PRIO +PASS: gdb.base/sigall.exp: handle SIGPRIO stop print +PASS: gdb.base/sigall.exp: b handle_PRIO +PASS: gdb.base/sigall.exp: b gen_33 +PASS: gdb.base/sigall.exp: send signal PRIO +PASS: gdb.base/sigall.exp: advance to 33 +PASS: gdb.base/sigall.exp: handle SIG33 stop print +PASS: gdb.base/sigall.exp: b handle_33 +PASS: gdb.base/sigall.exp: b gen_34 +PASS: gdb.base/sigall.exp: send signal 33 +PASS: gdb.base/sigall.exp: advance to 34 +PASS: gdb.base/sigall.exp: handle SIG34 stop print +PASS: gdb.base/sigall.exp: b handle_34 +PASS: gdb.base/sigall.exp: b gen_35 +PASS: gdb.base/sigall.exp: send signal 34 +PASS: gdb.base/sigall.exp: advance to 35 +PASS: gdb.base/sigall.exp: handle SIG35 stop print +PASS: gdb.base/sigall.exp: b handle_35 +PASS: gdb.base/sigall.exp: b gen_36 +PASS: gdb.base/sigall.exp: send signal 35 +PASS: gdb.base/sigall.exp: advance to 36 +PASS: gdb.base/sigall.exp: handle SIG36 stop print +PASS: gdb.base/sigall.exp: b handle_36 +PASS: gdb.base/sigall.exp: b gen_37 +PASS: gdb.base/sigall.exp: send signal 36 +PASS: gdb.base/sigall.exp: advance to 37 +PASS: gdb.base/sigall.exp: handle SIG37 stop print +PASS: gdb.base/sigall.exp: b handle_37 +PASS: gdb.base/sigall.exp: b gen_38 +PASS: gdb.base/sigall.exp: send signal 37 +PASS: gdb.base/sigall.exp: advance to 38 +PASS: gdb.base/sigall.exp: handle SIG38 stop print +PASS: gdb.base/sigall.exp: b handle_38 +PASS: gdb.base/sigall.exp: b gen_39 +PASS: gdb.base/sigall.exp: send signal 38 +PASS: gdb.base/sigall.exp: advance to 39 +PASS: gdb.base/sigall.exp: handle SIG39 stop print +PASS: gdb.base/sigall.exp: b handle_39 +PASS: gdb.base/sigall.exp: b gen_40 +PASS: gdb.base/sigall.exp: send signal 39 +PASS: gdb.base/sigall.exp: advance to 40 +PASS: gdb.base/sigall.exp: handle SIG40 stop print +PASS: gdb.base/sigall.exp: b handle_40 +PASS: gdb.base/sigall.exp: b gen_41 +PASS: gdb.base/sigall.exp: send signal 40 +PASS: gdb.base/sigall.exp: advance to 41 +PASS: gdb.base/sigall.exp: handle SIG41 stop print +PASS: gdb.base/sigall.exp: b handle_41 +PASS: gdb.base/sigall.exp: b gen_42 +PASS: gdb.base/sigall.exp: send signal 41 +PASS: gdb.base/sigall.exp: advance to 42 +PASS: gdb.base/sigall.exp: handle SIG42 stop print +PASS: gdb.base/sigall.exp: b handle_42 +PASS: gdb.base/sigall.exp: b gen_43 +PASS: gdb.base/sigall.exp: send signal 42 +PASS: gdb.base/sigall.exp: advance to 43 +PASS: gdb.base/sigall.exp: handle SIG43 stop print +PASS: gdb.base/sigall.exp: b handle_43 +PASS: gdb.base/sigall.exp: b gen_44 +PASS: gdb.base/sigall.exp: send signal 43 +PASS: gdb.base/sigall.exp: advance to 44 +PASS: gdb.base/sigall.exp: handle SIG44 stop print +PASS: gdb.base/sigall.exp: b handle_44 +PASS: gdb.base/sigall.exp: b gen_45 +PASS: gdb.base/sigall.exp: send signal 44 +PASS: gdb.base/sigall.exp: advance to 45 +PASS: gdb.base/sigall.exp: handle SIG45 stop print +PASS: gdb.base/sigall.exp: b handle_45 +PASS: gdb.base/sigall.exp: b gen_46 +PASS: gdb.base/sigall.exp: send signal 45 +PASS: gdb.base/sigall.exp: advance to 46 +PASS: gdb.base/sigall.exp: handle SIG46 stop print +PASS: gdb.base/sigall.exp: b handle_46 +PASS: gdb.base/sigall.exp: b gen_47 +PASS: gdb.base/sigall.exp: send signal 46 +PASS: gdb.base/sigall.exp: advance to 47 +PASS: gdb.base/sigall.exp: handle SIG47 stop print +PASS: gdb.base/sigall.exp: b handle_47 +PASS: gdb.base/sigall.exp: b gen_48 +PASS: gdb.base/sigall.exp: send signal 47 +PASS: gdb.base/sigall.exp: advance to 48 +PASS: gdb.base/sigall.exp: handle SIG48 stop print +PASS: gdb.base/sigall.exp: b handle_48 +PASS: gdb.base/sigall.exp: b gen_49 +PASS: gdb.base/sigall.exp: send signal 48 +PASS: gdb.base/sigall.exp: advance to 49 +PASS: gdb.base/sigall.exp: handle SIG49 stop print +PASS: gdb.base/sigall.exp: b handle_49 +PASS: gdb.base/sigall.exp: b gen_50 +PASS: gdb.base/sigall.exp: send signal 49 +PASS: gdb.base/sigall.exp: advance to 50 +PASS: gdb.base/sigall.exp: handle SIG50 stop print +PASS: gdb.base/sigall.exp: b handle_50 +PASS: gdb.base/sigall.exp: b gen_51 +PASS: gdb.base/sigall.exp: send signal 50 +PASS: gdb.base/sigall.exp: advance to 51 +PASS: gdb.base/sigall.exp: handle SIG51 stop print +PASS: gdb.base/sigall.exp: b handle_51 +PASS: gdb.base/sigall.exp: b gen_52 +PASS: gdb.base/sigall.exp: send signal 51 +PASS: gdb.base/sigall.exp: advance to 52 +PASS: gdb.base/sigall.exp: handle SIG52 stop print +PASS: gdb.base/sigall.exp: b handle_52 +PASS: gdb.base/sigall.exp: b gen_53 +PASS: gdb.base/sigall.exp: send signal 52 +PASS: gdb.base/sigall.exp: advance to 53 +PASS: gdb.base/sigall.exp: handle SIG53 stop print +PASS: gdb.base/sigall.exp: b handle_53 +PASS: gdb.base/sigall.exp: b gen_54 +PASS: gdb.base/sigall.exp: send signal 53 +PASS: gdb.base/sigall.exp: advance to 54 +PASS: gdb.base/sigall.exp: handle SIG54 stop print +PASS: gdb.base/sigall.exp: b handle_54 +PASS: gdb.base/sigall.exp: b gen_55 +PASS: gdb.base/sigall.exp: send signal 54 +PASS: gdb.base/sigall.exp: advance to 55 +PASS: gdb.base/sigall.exp: handle SIG55 stop print +PASS: gdb.base/sigall.exp: b handle_55 +PASS: gdb.base/sigall.exp: b gen_56 +PASS: gdb.base/sigall.exp: send signal 55 +PASS: gdb.base/sigall.exp: advance to 56 +PASS: gdb.base/sigall.exp: handle SIG56 stop print +PASS: gdb.base/sigall.exp: b handle_56 +PASS: gdb.base/sigall.exp: b gen_57 +PASS: gdb.base/sigall.exp: send signal 56 +PASS: gdb.base/sigall.exp: advance to 57 +PASS: gdb.base/sigall.exp: handle SIG57 stop print +PASS: gdb.base/sigall.exp: b handle_57 +PASS: gdb.base/sigall.exp: b gen_58 +PASS: gdb.base/sigall.exp: send signal 57 +PASS: gdb.base/sigall.exp: advance to 58 +PASS: gdb.base/sigall.exp: handle SIG58 stop print +PASS: gdb.base/sigall.exp: b handle_58 +PASS: gdb.base/sigall.exp: b gen_59 +PASS: gdb.base/sigall.exp: send signal 58 +PASS: gdb.base/sigall.exp: advance to 59 +PASS: gdb.base/sigall.exp: handle SIG59 stop print +PASS: gdb.base/sigall.exp: b handle_59 +PASS: gdb.base/sigall.exp: b gen_60 +PASS: gdb.base/sigall.exp: send signal 59 +PASS: gdb.base/sigall.exp: advance to 60 +PASS: gdb.base/sigall.exp: handle SIG60 stop print +PASS: gdb.base/sigall.exp: b handle_60 +PASS: gdb.base/sigall.exp: b gen_61 +PASS: gdb.base/sigall.exp: send signal 60 +PASS: gdb.base/sigall.exp: advance to 61 +PASS: gdb.base/sigall.exp: handle SIG61 stop print +PASS: gdb.base/sigall.exp: b handle_61 +PASS: gdb.base/sigall.exp: b gen_62 +PASS: gdb.base/sigall.exp: send signal 61 +PASS: gdb.base/sigall.exp: advance to 62 +PASS: gdb.base/sigall.exp: handle SIG62 stop print +PASS: gdb.base/sigall.exp: b handle_62 +PASS: gdb.base/sigall.exp: b gen_63 +PASS: gdb.base/sigall.exp: send signal 62 +PASS: gdb.base/sigall.exp: advance to 63 +PASS: gdb.base/sigall.exp: handle SIG63 stop print +PASS: gdb.base/sigall.exp: b handle_63 +PASS: gdb.base/sigall.exp: b gen_TERM +PASS: gdb.base/sigall.exp: send signal 63 +PASS: gdb.base/sigall.exp: advance to TERM +PASS: gdb.base/sigall.exp: handle SIGTERM stop print +PASS: gdb.base/sigall.exp: b handle_TERM +PASS: gdb.base/sigall.exp: get signal TERM +PASS: gdb.base/sigall.exp: send signal TERM +PASS: gdb.base/sigall.exp: continue until exit at continue to sigall exit +Running ./gdb.base/sigaltstack.exp ... +PASS: gdb.base/sigaltstack.exp: handle SIGALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGVTALRM print pass nostop +PASS: gdb.base/sigaltstack.exp: handle SIGPROF print pass nostop +PASS: gdb.base/sigaltstack.exp: break catcher if level == INNER +PASS: gdb.base/sigaltstack.exp: continue to catch +PASS: gdb.base/sigaltstack.exp: next +PASS: gdb.base/sigaltstack.exp: backtrace +PASS: gdb.base/sigaltstack.exp: finish from catch LEAF +PASS: gdb.base/sigaltstack.exp: finish to throw INNER +PASS: gdb.base/sigaltstack.exp: finish to catch INNER +PASS: gdb.base/sigaltstack.exp: finish from catch INNER +PASS: gdb.base/sigaltstack.exp: finish to OUTER +PASS: gdb.base/sigaltstack.exp: finish to catch MAIN +PASS: gdb.base/sigaltstack.exp: finish to MAIN +Running ./gdb.base/sigbpt.exp ... +PASS: gdb.base/sigbpt.exp: break keeper +PASS: gdb.base/sigbpt.exp: display/i $pc +PASS: gdb.base/sigbpt.exp: advance to the bowler +PASS: gdb.base/sigbpt.exp: stepping to fault +PASS: gdb.base/sigbpt.exp: get insn after fault +PASS: gdb.base/sigbpt.exp: Verify that SIGSEGV occurs at the last STEPI insn +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi; nopass SIGSEGV +KFAIL: gdb.base/sigbpt.exp: stepi; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp before segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp at segv; set breakpoint 0 of 1 +KFAIL: gdb.base/sigbpt.exp: stepi bp at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp at segv; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; continue to keeper +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; set breakpoint 1 of 2 +KFAIL: gdb.base/sigbpt.exp: stepi bp before and at segv; stepi out of handler (corrupt pc) (PRMS: gdb/1702) +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: stepi bp before and at segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; continue to keeper +PASS: gdb.base/sigbpt.exp: cont; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont; set breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: cont; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont; stepi fault +PASS: gdb.base/sigbpt.exp: cont; clear breakpoint 0 of 1 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; set breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont bp after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 0 of 2 +PASS: gdb.base/sigbpt.exp: cont bp after segv; clear breakpoint 1 of 2 +PASS: gdb.base/sigbpt.exp: rerun to main +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; pass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; continue to keeper +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; nopass SIGSEGV +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; set breakpoint 2 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; continue to breakpoint at fault +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; stepi fault +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 0 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 1 of 3 +PASS: gdb.base/sigbpt.exp: cont bp before and after segv; clear breakpoint 2 of 3 +Running ./gdb.base/sigchld.exp ... +PASS: gdb.base/sigchld.exp: set breakpoint at success exit +PASS: gdb.base/sigchld.exp: set breakpoint at failure exit +PASS: gdb.base/sigchld.exp: SIGCHLD blocked in inferior +Running ./gdb.base/siginfo-addr.exp ... +Running ./gdb.base/siginfo.exp ... +PASS: gdb.base/siginfo.exp: display/i $pc +PASS: gdb.base/siginfo.exp: break handler +PASS: gdb.base/siginfo.exp: continue to stepi handler +PASS: gdb.base/siginfo.exp: backtrace for nexti +PASS: gdb.base/siginfo.exp: step out of handler +Running ./gdb.base/siginfo-infcall.exp ... +PASS: gdb.base/siginfo-infcall.exp: continue to SIGUSR1 +PASS: gdb.base/siginfo-infcall.exp: p callme () +PASS: gdb.base/siginfo-infcall.exp: continue to the handler +Running ./gdb.base/siginfo-obj.exp ... +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: save a core file +PASS: gdb.base/siginfo-obj.exp: Extract si_addr +PASS: gdb.base/siginfo-obj.exp: Extract si_errno +PASS: gdb.base/siginfo-obj.exp: Extract si_code +PASS: gdb.base/siginfo-obj.exp: Extract si_signo +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +PASS: gdb.base/siginfo-obj.exp: continue to signal +PASS: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr = 0x666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno = 666 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_code = 999 +PASS: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo = 11 +PASS: gdb.base/siginfo-obj.exp: break 38 +PASS: gdb.base/siginfo-obj.exp: continue to handler +PASS: gdb.base/siginfo-obj.exp: p ssi_addr +PASS: gdb.base/siginfo-obj.exp: p ssi_errno +PASS: gdb.base/siginfo-obj.exp: p ssi_code +PASS: gdb.base/siginfo-obj.exp: p ssi_signo +FAIL: gdb.base/siginfo-obj.exp: core siginfo-obj.gcore +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_signo from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_errno from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo.si_code from core file +FAIL: gdb.base/siginfo-obj.exp: p $_siginfo._sifields._sigfault.si_addr from core file +Running ./gdb.base/siginfo-thread.exp ... +PASS: gdb.base/siginfo-thread.exp: successfully compiled posix threads test case +PASS: gdb.base/siginfo-thread.exp: continue to signal +PASS: gdb.base/siginfo-thread.exp: save a core file +PASS: gdb.base/siginfo-thread.exp: Extract si_addr +PASS: gdb.base/siginfo-thread.exp: Extract si_errno +PASS: gdb.base/siginfo-thread.exp: Extract si_code +PASS: gdb.base/siginfo-thread.exp: Extract si_signo +PASS: gdb.base/siginfo-thread.exp: break 39 +PASS: gdb.base/siginfo-thread.exp: continue to handler +PASS: gdb.base/siginfo-thread.exp: p ssi_addr +PASS: gdb.base/siginfo-thread.exp: p ssi_errno +PASS: gdb.base/siginfo-thread.exp: p ssi_code +PASS: gdb.base/siginfo-thread.exp: p ssi_signo +PASS: gdb.base/siginfo-thread.exp: thread 1 +PASS: gdb.base/siginfo-thread.exp: test signal in main thread +FAIL: gdb.base/siginfo-thread.exp: core siginfo-thread.gcore +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_signo from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_errno from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo.si_code from core file +FAIL: gdb.base/siginfo-thread.exp: p $_siginfo._sifields._sigfault.si_addr from core file +PASS: gdb.base/siginfo-thread.exp: set variable $count = 0 +PASS: gdb.base/siginfo-thread.exp: select thread 1 with core file +FAIL: gdb.base/siginfo-thread.exp: update counter in thread 1 +PASS: gdb.base/siginfo-thread.exp: select thread 2 with core file +FAIL: gdb.base/siginfo-thread.exp: update counter in thread 2 +FAIL: gdb.base/siginfo-thread.exp: print $count +Running ./gdb.base/signals.exp ... +PASS: gdb.base/signals.exp: handle all print +PASS: gdb.base/signals.exp: set variable count = 0 +PASS: gdb.base/signals.exp: break handler if 0 +PASS: gdb.base/signals.exp: set $handler_breakpoint_number = $bpnum +PASS: gdb.base/signals.exp: next to signal +PASS: gdb.base/signals.exp: next to alarm #1 +PASS: gdb.base/signals.exp: next to ++count #1 +PASS: gdb.base/signals.exp: p func1 () #1 +PASS: gdb.base/signals.exp: p count #1 +PASS: gdb.base/signals.exp: condition $handler_breakpoint_number +PASS: gdb.base/signals.exp: next to alarm #2 +PASS: gdb.base/signals.exp: next to ++count #2 +PASS: gdb.base/signals.exp: p func1 () #2 +PASS: gdb.base/signals.exp: backtrace from handler when calling func1 +PASS: gdb.base/signals.exp: continue +PASS: gdb.base/signals.exp: p count #2 +PASS: gdb.base/signals.exp: info signals +PASS: gdb.base/signals.exp: info signal SIGTRAP +PASS: gdb.base/signals.exp: info signal 5 +PASS: gdb.base/signals.exp: handle without arguments +PASS: gdb.base/signals.exp: handle with bogus SIG +PASS: gdb.base/signals.exp: handle SIG with bogus action +PASS: gdb.base/signals.exp: handle SIG with multiple conflicting actions +PASS: gdb.base/signals.exp: handle SIG parses all legal actions +PASS: gdb.base/signals.exp: handle multiple SIGs +PASS: gdb.base/signals.exp: override SIGTRAP +PASS: gdb.base/signals.exp: invalid signal number rejected +PASS: gdb.base/signals.exp: handle multiple SIGs via integer range +PASS: gdb.base/signals.exp: handle multiple SIGs via reverse integer range +PASS: gdb.base/signals.exp: override SIGINT +PASS: gdb.base/signals.exp: signal without arguments disallowed +PASS: gdb.base/signals.exp: signal SIGUSR1 +PASS: gdb.base/signals.exp: backtrace for SIGUSR1 +Running ./gdb.base/signest.exp ... +PASS: gdb.base/signest.exp: continue to fault +PASS: gdb.base/signest.exp: set conditional breakpoint +PASS: gdb.base/signest.exp: pass SIGSEGV +PASS: gdb.base/signest.exp: pass SIGBUS +PASS: gdb.base/signest.exp: run through nested faults +Running ./gdb.base/signull.exp ... +PASS: gdb.base/signull.exp: set for function pointer probe +PASS: gdb.base/signull.exp: probe function pointer (function entry-point) +PASS: gdb.base/signull.exp: rerun to main +PASS: gdb.base/signull.exp: break bowler +PASS: gdb.base/signull.exp: break keeper +PASS: gdb.base/signull.exp: handle SIGSEGV +PASS: gdb.base/signull.exp: handle SIGBUS +PASS: gdb.base/signull.exp: data read; start with the bowler +PASS: gdb.base/signull.exp: data read; select the pointer type +PASS: gdb.base/signull.exp: data read; take the SIGSEGV +PASS: gdb.base/signull.exp: data read; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data read; continue to the keeper +PASS: gdb.base/signull.exp: data read; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: data write; start with the bowler +PASS: gdb.base/signull.exp: data write; select the pointer type +PASS: gdb.base/signull.exp: data write; take the SIGSEGV +PASS: gdb.base/signull.exp: data write; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: data write; continue to the keeper +PASS: gdb.base/signull.exp: data write; backtrace from keeper through SIGSEGV +PASS: gdb.base/signull.exp: code; start with the bowler +PASS: gdb.base/signull.exp: code; select the pointer type +PASS: gdb.base/signull.exp: code; take the SIGSEGV +PASS: gdb.base/signull.exp: code; backtrace from SIGSEGV +PASS: gdb.base/signull.exp: code; continue to the keeper +PASS: gdb.base/signull.exp: code; backtrace from keeper through SIGSEGV +Running ./gdb.base/sigrepeat.exp ... +PASS: gdb.base/sigrepeat.exp: advance to infinite loop +PASS: gdb.base/sigrepeat.exp: next +Running ./gdb.base/sigstep.exp ... +PASS: gdb.base/sigstep.exp: display/i $pc +PASS: gdb.base/sigstep.exp: break handler +PASS: gdb.base/sigstep.exp: continue to stepi handler +PASS: gdb.base/sigstep.exp: backtrace for nexti +PASS: gdb.base/sigstep.exp: step from handler; continue to handler +PASS: gdb.base/sigstep.exp: step from handler; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; continue to handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave handler +PASS: gdb.base/sigstep.exp: stepi from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: next from handler; continue to handler +PASS: gdb.base/sigstep.exp: next from handler; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; continue to handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave handler +PASS: gdb.base/sigstep.exp: nexti from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: finish from handleri; continue to handler +PASS: gdb.base/sigstep.exp: finish from handleri; leave handler +PASS: gdb.base/sigstep.exp: finish from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: return from handleri; continue to handler +PASS: gdb.base/sigstep.exp: return from handleri; leave handler +PASS: gdb.base/sigstep.exp: return from handleri; leave signal trampoline (in main) +PASS: gdb.base/sigstep.exp: Set done as return will have skipped it +PASS: gdb.base/sigstep.exp: set itimer = itimer_real +PASS: gdb.base/sigstep.exp: break 79 +PASS: gdb.base/sigstep.exp: step to handler; resync +PASS: gdb.base/sigstep.exp: step to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler; break handler +PASS: gdb.base/sigstep.exp: step to handler; performing step +PASS: gdb.base/sigstep.exp: step to handler; clear handler +PASS: gdb.base/sigstep.exp: next to handler; resync +PASS: gdb.base/sigstep.exp: next to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler; break handler +PASS: gdb.base/sigstep.exp: next to handler; performing next +PASS: gdb.base/sigstep.exp: next to handler; clear handler +PASS: gdb.base/sigstep.exp: continue to handler; resync +PASS: gdb.base/sigstep.exp: continue to handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler; break handler +PASS: gdb.base/sigstep.exp: continue to handler; performing continue +PASS: gdb.base/sigstep.exp: continue to handler; clear handler +PASS: gdb.base/sigstep.exp: step to handler entry; resync +PASS: gdb.base/sigstep.exp: step to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: step to handler entry; break handler +PASS: gdb.base/sigstep.exp: step to handler entry; performing step +PASS: gdb.base/sigstep.exp: step to handler entry; clear handler +PASS: gdb.base/sigstep.exp: next to handler entry; resync +PASS: gdb.base/sigstep.exp: next to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: next to handler entry; break handler +PASS: gdb.base/sigstep.exp: next to handler entry; performing next +PASS: gdb.base/sigstep.exp: next to handler entry; clear handler +PASS: gdb.base/sigstep.exp: continue to handler entry; resync +PASS: gdb.base/sigstep.exp: continue to handler entry; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue to handler entry; break handler +PASS: gdb.base/sigstep.exp: continue to handler entry; performing continue +PASS: gdb.base/sigstep.exp: continue to handler entry; clear handler +PASS: gdb.base/sigstep.exp: step over handler; resync +PASS: gdb.base/sigstep.exp: step over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: step over handler; performing step +PASS: gdb.base/sigstep.exp: next over handler; resync +PASS: gdb.base/sigstep.exp: next over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: next over handler; performing next +PASS: gdb.base/sigstep.exp: continue over handler; resync +PASS: gdb.base/sigstep.exp: continue over handler; advance to infinite loop +PASS: gdb.base/sigstep.exp: continue over handler; performing continue +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; break handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler; clear handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; break handler +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, to handler entry; clear handler +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; performing step +PASS: gdb.base/sigstep.exp: step on breakpoint, skip handler; clear infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; performing next +PASS: gdb.base/sigstep.exp: next on breakpoint, skip handler; clear infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; resync +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; break infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; continue to infinite loop +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; performing continue +PASS: gdb.base/sigstep.exp: continue on breakpoint, skip handler; clear infinite loop +Running ./gdb.base/sizeof.exp ... +Running ./gdb.base/skip.exp ... +PASS: gdb.base/skip.exp: skip file (no default file) +PASS: gdb.base/skip.exp: skip function +PASS: gdb.base/skip.exp: skip (no default function) +PASS: gdb.base/skip.exp: info skip empty +PASS: gdb.base/skip.exp: skip file (skip.c) +PASS: gdb.base/skip.exp: skip (main) +PASS: gdb.base/skip.exp: skip file skip1.c +PASS: gdb.base/skip.exp: skip function baz +PASS: gdb.base/skip.exp: skip enable 999 +PASS: gdb.base/skip.exp: skip disable 999 +PASS: gdb.base/skip.exp: skip delete 999 +PASS: gdb.base/skip.exp: skip enable a +PASS: gdb.base/skip.exp: skip disable a +PASS: gdb.base/skip.exp: skip delete a +PASS: gdb.base/skip.exp: info skip 999 +PASS: gdb.base/skip.exp: info skip +PASS: gdb.base/skip.exp: step in the main +PASS: gdb.base/skip.exp: step after all ignored +PASS: gdb.base/skip.exp: skip delete 1 +PASS: gdb.base/skip.exp: info skip (delete 1) +PASS: gdb.base/skip.exp: step after deleting 1 (1) +PASS: gdb.base/skip.exp: step after deleting 1 (2) +PASS: gdb.base/skip.exp: step after deleting 1 (3) +PASS: gdb.base/skip.exp: skip disable 3 +PASS: gdb.base/skip.exp: info skip shows entry as disabled +PASS: gdb.base/skip.exp: step after disabling 3 (1) +PASS: gdb.base/skip.exp: step after disabling 3 (2) +PASS: gdb.base/skip.exp: step after disabling 3 (3) +PASS: gdb.base/skip.exp: step after disabling 3 (4) +PASS: gdb.base/skip.exp: step after disabling 3 (5) +PASS: gdb.base/skip.exp: skip enable 3 +PASS: gdb.base/skip.exp: info skip shows entry as enabled +PASS: gdb.base/skip.exp: step after enable 3 (1) +PASS: gdb.base/skip.exp: step after enable 3 (2) +PASS: gdb.base/skip.exp: step after enable 3 (3) +PASS: gdb.base/skip.exp: skip disable +PASS: gdb.base/skip.exp: info skip after disabling all +PASS: gdb.base/skip.exp: skip enable +PASS: gdb.base/skip.exp: info skip after enabling all +PASS: gdb.base/skip.exp: skip disable 4 2-3 +PASS: gdb.base/skip.exp: info skip after disabling 4 2-3 +PASS: gdb.base/skip.exp: skip enable 2-3 +PASS: gdb.base/skip.exp: info skip after enabling 2-3 +PASS: gdb.base/skip.exp: info skip 2-3 +PASS: gdb.base/skip.exp: skip delete 2 3 +PASS: gdb.base/skip.exp: info skip after deleting 2 3 +PASS: gdb.base/skip.exp: skip delete +PASS: gdb.base/skip.exp: info skip after deleting all +Running ./gdb.base/skip-solib.exp ... +Running ./gdb.base/so-impl-ld.exp ... +PASS: gdb.base/so-impl-ld.exp: step over solib call +PASS: gdb.base/so-impl-ld.exp: step into solib call +PASS: gdb.base/so-impl-ld.exp: step in solib call +PASS: gdb.base/so-impl-ld.exp: step out of solib call +Running ./gdb.base/so-indr-cl.exp ... +Running ./gdb.base/solib-corrupted.exp ... +Running ./gdb.base/solib-disc.exp ... +PASS: gdb.base/solib-disc.exp: set stop-on-solib-events 1 +PASS: gdb.base/solib-disc.exp: continue to load +PASS: gdb.base/solib-disc.exp: save $pc after load +PASS: gdb.base/solib-disc.exp: disconnect after load +PASS: gdb.base/solib-disc.exp: reconnect after load +PASS: gdb.base/solib-disc.exp: check $pc after load +PASS: gdb.base/solib-disc.exp: continue to unload +PASS: gdb.base/solib-disc.exp: save $pc after unload +PASS: gdb.base/solib-disc.exp: disconnect after unload +PASS: gdb.base/solib-disc.exp: reconnect after unload +PASS: gdb.base/solib-disc.exp: check $pc after unload +Running ./gdb.base/solib-display.exp ... +Running ./gdb.base/solib.exp ... +Running ./gdb.base/solib-nodir.exp ... +Running ./gdb.base/solib-overlap.exp ... +Running ./gdb.base/solib-symbol.exp ... +PASS: gdb.base/solib-symbol.exp: foo2 in main +PASS: gdb.base/solib-symbol.exp: foo in libmd +PASS: gdb.base/solib-symbol.exp: continue +PASS: gdb.base/solib-symbol.exp: foo2 in mdlib +Running ./gdb.base/solib-weak.exp ... +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 nodebug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 nodebug, lib2 debug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 nodebug, lib2 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib1 first +PASS: gdb.base/solib-weak.exp: run to breakpoint - lib1 debug, lib2 debug, lib2 first +Running ./gdb.base/source.exp ... +PASS: gdb.base/source.exp: script contains error +PASS: gdb.base/source.exp: source -v +PASS: gdb.base/source.exp: source after -v +PASS: gdb.base/source.exp: set search directories +PASS: gdb.base/source.exp: source -s +PASS: gdb.base/source.exp: source -s -v +PASS: gdb.base/source.exp: source -v -s +Running ./gdb.base/stack-checking.exp ... +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for small frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for medium frame +PASS: gdb.base/stack-checking.exp: bt +PASS: gdb.base/stack-checking.exp: continue to breakpoint: breakpoint for big frame +PASS: gdb.base/stack-checking.exp: bt +Running ./gdb.base/stale-infcall.exp ... +PASS: gdb.base/stale-infcall.exp: continue to breakpoint: test-next +PASS: gdb.base/stale-infcall.exp: set $test_fail_bpnum=$bpnum +XFAIL: gdb.base/stale-infcall.exp: test system longjmp tracking support +UNTESTED: gdb.base/stale-infcall.exp: System lacks support for tracking longjmps +Running ./gdb.base/stap-probe.exp ... +gdb compile failed, ./gdb.base/stap-probe.c:39:21: fatal error: sys/sdt.h: No such file or directory + #include <sys/sdt.h> + ^ +compilation terminated. +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +UNTESTED: gdb.base/stap-probe.exp: without semaphore, not optimized: stap-probe.exp +Running ./gdb.base/start.exp ... +UNTESTED: gdb.base/start.exp: start +Running ./gdb.base/step-break.exp ... +PASS: gdb.base/step-break.exp: breakpoint line number +PASS: gdb.base/step-break.exp: run until breakpoint set at a line number +PASS: gdb.base/step-break.exp: next 2 (1) +PASS: gdb.base/step-break.exp: next 2 (2) +PASS: gdb.base/step-break.exp: next 2 (3) +PASS: gdb.base/step-break.exp: next 2 (4) +PASS: gdb.base/step-break.exp: next 2 (5) +PASS: gdb.base/step-break.exp: next 2 (6) +Running ./gdb.base/step-bt.exp ... +PASS: gdb.base/step-bt.exp: breakpoint at first instruction of hello() +PASS: gdb.base/step-bt.exp: run to hello() +PASS: gdb.base/step-bt.exp: step first instruction +PASS: gdb.base/step-bt.exp: backtrace after first instruction step +PASS: gdb.base/step-bt.exp: step second instruction +PASS: gdb.base/step-bt.exp: backtrace after second instruction step +Running ./gdb.base/step-line.exp ... +PASS: gdb.base/step-line.exp: break f1 +PASS: gdb.base/step-line.exp: continue to f1 +PASS: gdb.base/step-line.exp: next over dummy 1 +PASS: gdb.base/step-line.exp: next to dummy 2 +PASS: gdb.base/step-line.exp: next over dummy 2 +PASS: gdb.base/step-line.exp: step into f2 +PASS: gdb.base/step-line.exp: next over dummy 4 +PASS: gdb.base/step-line.exp: next to dummy 5 +PASS: gdb.base/step-line.exp: next to dummy 6 +PASS: gdb.base/step-line.exp: next over dummy 6 +PASS: gdb.base/step-line.exp: next to dummy 7 +PASS: gdb.base/step-line.exp: next to dummy 8 +PASS: gdb.base/step-line.exp: next over dummy 8 +PASS: gdb.base/step-line.exp: next to dummy 9 +PASS: gdb.base/step-line.exp: next to dummy 10 +PASS: gdb.base/step-line.exp: next over dummy 10 +Running ./gdb.base/step-resume-infcall.exp ... +PASS: gdb.base/step-resume-infcall.exp: step +PASS: gdb.base/step-resume-infcall.exp: up +PASS: gdb.base/step-resume-infcall.exp: set $b=$pc +PASS: gdb.base/step-resume-infcall.exp: print $bpnum +PASS: gdb.base/step-resume-infcall.exp: disass/m +PASS: gdb.base/step-resume-infcall.exp: info breakpoints +PASS: gdb.base/step-resume-infcall.exp: next +PASS: gdb.base/step-resume-infcall.exp: p cond_hit +Running ./gdb.base/step-symless.exp ... +PASS: gdb.base/step-symless.exp: strip stub symbols +PASS: gdb.base/step-symless.exp: step +Running ./gdb.base/step-test.exp ... +PASS: gdb.base/step-test.exp: next 1 +PASS: gdb.base/step-test.exp: step 1 +PASS: gdb.base/step-test.exp: next 2 +PASS: gdb.base/step-test.exp: step 3 +PASS: gdb.base/step-test.exp: next 3 +PASS: gdb.base/step-test.exp: next over +PASS: gdb.base/step-test.exp: step into +PASS: gdb.base/step-test.exp: step out +PASS: gdb.base/step-test.exp: stepi to next line +PASS: gdb.base/step-test.exp: stepi into function +PASS: gdb.base/step-test.exp: stepi into function's first source line +PASS: gdb.base/step-test.exp: stepi: finish call +PASS: gdb.base/step-test.exp: nexti over function +PASS: gdb.base/step-test.exp: set breakpoint at call to large_struct_by_value +PASS: gdb.base/step-test.exp: run to pass large struct +PASS: gdb.base/step-test.exp: large struct by value +PASS: gdb.base/step-test.exp: continue until exit at step-test.exp +Running ./gdb.base/store.exp ... +PASS: gdb.base/store.exp: tbreak wack_charest +PASS: gdb.base/store.exp: continue to wack_charest +PASS: gdb.base/store.exp: var charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: var charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: var charest l; setting l to 4 +PASS: gdb.base/store.exp: var charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: var charest l; next over add call +PASS: gdb.base/store.exp: var charest l; print incremented l, expecting 2 ..002. +PASS: gdb.base/store.exp: tbreak wack_short +PASS: gdb.base/store.exp: continue to wack_short +PASS: gdb.base/store.exp: var short l; print old l, expecting -1 +PASS: gdb.base/store.exp: var short l; print old r, expecting -2 +PASS: gdb.base/store.exp: var short l; setting l to 4 +PASS: gdb.base/store.exp: var short l; print new l, expecting 4 +PASS: gdb.base/store.exp: var short l; next over add call +PASS: gdb.base/store.exp: var short l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_int +PASS: gdb.base/store.exp: continue to wack_int +PASS: gdb.base/store.exp: var int l; print old l, expecting -1 +PASS: gdb.base/store.exp: var int l; print old r, expecting -2 +PASS: gdb.base/store.exp: var int l; setting l to 4 +PASS: gdb.base/store.exp: var int l; print new l, expecting 4 +PASS: gdb.base/store.exp: var int l; next over add call +PASS: gdb.base/store.exp: var int l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_long +PASS: gdb.base/store.exp: continue to wack_long +PASS: gdb.base/store.exp: var long l; print old l, expecting -1 +PASS: gdb.base/store.exp: var long l; print old r, expecting -2 +PASS: gdb.base/store.exp: var long l; setting l to 4 +PASS: gdb.base/store.exp: var long l; print new l, expecting 4 +PASS: gdb.base/store.exp: var long l; next over add call +PASS: gdb.base/store.exp: var long l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_longest +PASS: gdb.base/store.exp: continue to wack_longest +PASS: gdb.base/store.exp: var longest l; print old l, expecting -1 +PASS: gdb.base/store.exp: var longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: var longest l; setting l to 4 +PASS: gdb.base/store.exp: var longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var longest l; next over add call +PASS: gdb.base/store.exp: var longest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_float +PASS: gdb.base/store.exp: continue to wack_float +PASS: gdb.base/store.exp: var float l; print old l, expecting -1 +PASS: gdb.base/store.exp: var float l; print old r, expecting -2 +PASS: gdb.base/store.exp: var float l; setting l to 4 +PASS: gdb.base/store.exp: var float l; print new l, expecting 4 +PASS: gdb.base/store.exp: var float l; next over add call +PASS: gdb.base/store.exp: var float l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_double +PASS: gdb.base/store.exp: continue to wack_double +PASS: gdb.base/store.exp: var double l; print old l, expecting -1 +PASS: gdb.base/store.exp: var double l; print old r, expecting -2 +PASS: gdb.base/store.exp: var double l; setting l to 4 +PASS: gdb.base/store.exp: var double l; print new l, expecting 4 +PASS: gdb.base/store.exp: var double l; next over add call +PASS: gdb.base/store.exp: var double l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak wack_doublest +PASS: gdb.base/store.exp: continue to wack_doublest +FAIL: gdb.base/store.exp: var doublest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: var doublest l; print old r, expecting -2 +FAIL: gdb.base/store.exp: var doublest l; setting l to 4 +FAIL: gdb.base/store.exp: var doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: var doublest l; next over add call +FAIL: gdb.base/store.exp: var doublest l; print incremented l, expecting 2 +PASS: gdb.base/store.exp: tbreak add_charest +PASS: gdb.base/store.exp: continue to add_charest +PASS: gdb.base/store.exp: upvar charest l; up +PASS: gdb.base/store.exp: upvar charest l; print old l, expecting -1 .* +PASS: gdb.base/store.exp: upvar charest l; print old r, expecting -2 .* +PASS: gdb.base/store.exp: upvar charest l; set l to 4 +PASS: gdb.base/store.exp: upvar charest l; print new l, expecting 4 ..004. +PASS: gdb.base/store.exp: tbreak add_short +PASS: gdb.base/store.exp: continue to add_short +PASS: gdb.base/store.exp: upvar short l; up +PASS: gdb.base/store.exp: upvar short l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar short l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar short l; set l to 4 +PASS: gdb.base/store.exp: upvar short l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_int +PASS: gdb.base/store.exp: continue to add_int +PASS: gdb.base/store.exp: upvar int l; up +PASS: gdb.base/store.exp: upvar int l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar int l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar int l; set l to 4 +PASS: gdb.base/store.exp: upvar int l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_long +PASS: gdb.base/store.exp: continue to add_long +PASS: gdb.base/store.exp: upvar long l; up +PASS: gdb.base/store.exp: upvar long l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar long l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar long l; set l to 4 +PASS: gdb.base/store.exp: upvar long l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_longest +PASS: gdb.base/store.exp: continue to add_longest +PASS: gdb.base/store.exp: upvar longest l; up +PASS: gdb.base/store.exp: upvar longest l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar longest l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar longest l; set l to 4 +PASS: gdb.base/store.exp: upvar longest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_float +PASS: gdb.base/store.exp: continue to add_float +PASS: gdb.base/store.exp: upvar float l; up +PASS: gdb.base/store.exp: upvar float l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar float l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar float l; set l to 4 +PASS: gdb.base/store.exp: upvar float l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_double +PASS: gdb.base/store.exp: continue to add_double +PASS: gdb.base/store.exp: upvar double l; up +PASS: gdb.base/store.exp: upvar double l; print old l, expecting -1 +PASS: gdb.base/store.exp: upvar double l; print old r, expecting -2 +PASS: gdb.base/store.exp: upvar double l; set l to 4 +PASS: gdb.base/store.exp: upvar double l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak add_doublest +PASS: gdb.base/store.exp: continue to add_doublest +PASS: gdb.base/store.exp: upvar doublest l; up +FAIL: gdb.base/store.exp: upvar doublest l; print old l, expecting -1 +FAIL: gdb.base/store.exp: upvar doublest l; print old r, expecting -2 +FAIL: gdb.base/store.exp: upvar doublest l; set l to 4 +FAIL: gdb.base/store.exp: upvar doublest l; print new l, expecting 4 +PASS: gdb.base/store.exp: tbreak wack_struct_1 +PASS: gdb.base/store.exp: continue to wack_struct_1 +PASS: gdb.base/store.exp: var struct 1 u; next to add_struct_1 call +PASS: gdb.base/store.exp: var struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: var struct 1 u; set u to s_1 +PASS: gdb.base/store.exp: var struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak wack_struct_2 +PASS: gdb.base/store.exp: continue to wack_struct_2 +PASS: gdb.base/store.exp: var struct 2 u; next to add_struct_2 call +PASS: gdb.base/store.exp: var struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: var struct 2 u; set u to s_2 +PASS: gdb.base/store.exp: var struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak wack_struct_3 +PASS: gdb.base/store.exp: continue to wack_struct_3 +PASS: gdb.base/store.exp: var struct 3 u; next to add_struct_3 call +PASS: gdb.base/store.exp: var struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: var struct 3 u; set u to s_3 +PASS: gdb.base/store.exp: var struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak wack_struct_4 +PASS: gdb.base/store.exp: continue to wack_struct_4 +PASS: gdb.base/store.exp: var struct 4 u; next to add_struct_4 call +PASS: gdb.base/store.exp: var struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: var struct 4 u; set u to s_4 +PASS: gdb.base/store.exp: var struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak add_struct_1 +PASS: gdb.base/store.exp: continue to add_struct_1 +PASS: gdb.base/store.exp: up struct 1 u; up +PASS: gdb.base/store.exp: up struct 1 u; print old u, expecting {s = \{0}} +PASS: gdb.base/store.exp: up struct 1 u; set u to s_1 +PASS: gdb.base/store.exp: up struct 1 u; print new u, expecting {s = \{1}} +PASS: gdb.base/store.exp: tbreak add_struct_2 +PASS: gdb.base/store.exp: continue to add_struct_2 +PASS: gdb.base/store.exp: up struct 2 u; up +PASS: gdb.base/store.exp: up struct 2 u; print old u, expecting {s = \{0, 0}} +PASS: gdb.base/store.exp: up struct 2 u; set u to s_2 +PASS: gdb.base/store.exp: up struct 2 u; print new u, expecting {s = \{1, 2}} +PASS: gdb.base/store.exp: tbreak add_struct_3 +PASS: gdb.base/store.exp: continue to add_struct_3 +PASS: gdb.base/store.exp: up struct 3 u; up +PASS: gdb.base/store.exp: up struct 3 u; print old u, expecting {s = \{0, 0, 0}} +PASS: gdb.base/store.exp: up struct 3 u; set u to s_3 +PASS: gdb.base/store.exp: up struct 3 u; print new u, expecting {s = \{1, 2, 3}} +PASS: gdb.base/store.exp: tbreak add_struct_4 +PASS: gdb.base/store.exp: continue to add_struct_4 +PASS: gdb.base/store.exp: up struct 4 u; up +PASS: gdb.base/store.exp: up struct 4 u; print old u, expecting {s = \{0, 0, 0, 0}} +PASS: gdb.base/store.exp: up struct 4 u; set u to s_4 +PASS: gdb.base/store.exp: up struct 4 u; print new u, expecting {s = \{1, 2, 3, 4}} +PASS: gdb.base/store.exp: tbreak wack_field_1 +PASS: gdb.base/store.exp: continue field 1 +PASS: gdb.base/store.exp: next field 1 +PASS: gdb.base/store.exp: old field 1 +PASS: gdb.base/store.exp: set variable u = F_1 +PASS: gdb.base/store.exp: new field 1 +PASS: gdb.base/store.exp: set variable u = F_1, u.i = f_1.i +PASS: gdb.base/store.exp: f_1.i +PASS: gdb.base/store.exp: set variable u = F_1, u.j = f_1.j +PASS: gdb.base/store.exp: f_1.j +PASS: gdb.base/store.exp: set variable u = F_1, u.k = f_1.k +PASS: gdb.base/store.exp: f_1.k +PASS: gdb.base/store.exp: set variable u = f_1, u.i = F_1.i +PASS: gdb.base/store.exp: F_1.i +PASS: gdb.base/store.exp: set variable u = f_1, u.j = F_1.j +PASS: gdb.base/store.exp: F_1.j +PASS: gdb.base/store.exp: set variable u = f_1, u.k = F_1.k +PASS: gdb.base/store.exp: F_1.k +PASS: gdb.base/store.exp: tbreak wack_field_2 +PASS: gdb.base/store.exp: continue field 2 +PASS: gdb.base/store.exp: next field 2 +PASS: gdb.base/store.exp: old field 2 +PASS: gdb.base/store.exp: set variable u = F_2 +PASS: gdb.base/store.exp: new field 2 +PASS: gdb.base/store.exp: set variable u = F_2, u.i = f_2.i +PASS: gdb.base/store.exp: f_2.i +PASS: gdb.base/store.exp: set variable u = F_2, u.j = f_2.j +PASS: gdb.base/store.exp: f_2.j +PASS: gdb.base/store.exp: set variable u = F_2, u.k = f_2.k +PASS: gdb.base/store.exp: f_2.k +PASS: gdb.base/store.exp: set variable u = f_2, u.i = F_2.i +PASS: gdb.base/store.exp: F_2.i +PASS: gdb.base/store.exp: set variable u = f_2, u.j = F_2.j +PASS: gdb.base/store.exp: F_2.j +PASS: gdb.base/store.exp: set variable u = f_2, u.k = F_2.k +PASS: gdb.base/store.exp: F_2.k +PASS: gdb.base/store.exp: tbreak wack_field_3 +PASS: gdb.base/store.exp: continue field 3 +PASS: gdb.base/store.exp: next field 3 +PASS: gdb.base/store.exp: old field 3 +PASS: gdb.base/store.exp: set variable u = F_3 +PASS: gdb.base/store.exp: new field 3 +PASS: gdb.base/store.exp: set variable u = F_3, u.i = f_3.i +PASS: gdb.base/store.exp: f_3.i +PASS: gdb.base/store.exp: set variable u = F_3, u.j = f_3.j +PASS: gdb.base/store.exp: f_3.j +PASS: gdb.base/store.exp: set variable u = F_3, u.k = f_3.k +PASS: gdb.base/store.exp: f_3.k +PASS: gdb.base/store.exp: set variable u = f_3, u.i = F_3.i +PASS: gdb.base/store.exp: F_3.i +PASS: gdb.base/store.exp: set variable u = f_3, u.j = F_3.j +PASS: gdb.base/store.exp: F_3.j +PASS: gdb.base/store.exp: set variable u = f_3, u.k = F_3.k +PASS: gdb.base/store.exp: F_3.k +PASS: gdb.base/store.exp: tbreak wack_field_4 +PASS: gdb.base/store.exp: continue field 4 +PASS: gdb.base/store.exp: next field 4 +PASS: gdb.base/store.exp: old field 4 +PASS: gdb.base/store.exp: set variable u = F_4 +PASS: gdb.base/store.exp: new field 4 +PASS: gdb.base/store.exp: set variable u = F_4, u.i = f_4.i +PASS: gdb.base/store.exp: f_4.i +PASS: gdb.base/store.exp: set variable u = F_4, u.j = f_4.j +PASS: gdb.base/store.exp: f_4.j +PASS: gdb.base/store.exp: set variable u = F_4, u.k = f_4.k +PASS: gdb.base/store.exp: f_4.k +PASS: gdb.base/store.exp: set variable u = f_4, u.i = F_4.i +PASS: gdb.base/store.exp: F_4.i +PASS: gdb.base/store.exp: set variable u = f_4, u.j = F_4.j +PASS: gdb.base/store.exp: F_4.j +PASS: gdb.base/store.exp: set variable u = f_4, u.k = F_4.k +PASS: gdb.base/store.exp: F_4.k +Running ./gdb.base/structs2.exp ... +PASS: gdb.base/structs2.exp: set width 0 +PASS: gdb.base/structs2.exp: structs2 sanity check +PASS: gdb.base/structs2.exp: structs2 breakpoint set +PASS: gdb.base/structs2.exp: structs2 continue1 +PASS: gdb.base/structs2.exp: structs2 continue2 +Running ./gdb.base/structs3.exp ... +PASS: gdb.base/structs3.exp: print two +PASS: gdb.base/structs3.exp: print *twop +PASS: gdb.base/structs3.exp: print *(struct Two *)onep +PASS: gdb.base/structs3.exp: print *(tTwo *)onep +Running ./gdb.base/structs.exp ... +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: continue to breakpoint: chartest-done +PASS: gdb.base/structs.exp: p chartest +PASS: gdb.base/structs.exp: ptype foo1; structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 9 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 9 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 9 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 10 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 10 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 10 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 11 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 11 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 11 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 12 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 12 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 12 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 13 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 13 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 13 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 14 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 14 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 14 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 15 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 15 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 15 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 16 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 16 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 16 structs-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 17 structs-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 17 structs-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 17 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 5 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 5 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 5 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 5 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 5 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 6 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 6 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 6 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 6 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 6 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 7 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 7 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 7 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 7 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 7 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 8 structs-tc +PASS: gdb.base/structs.exp: return foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 8 structs-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 8 structs-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 8 structs-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 8 structs-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 8 structs-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 3 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 3 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 3 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 3 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 3 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 4 structs-ts +PASS: gdb.base/structs.exp: return foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 4 structs-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 4 structs-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 4 structs-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 4 structs-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 4 structs-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tll +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tll +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tll +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tll +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tll +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-td +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-td +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-td +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo1; structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 1 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 1 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 1 structs-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for return; return 1 structs-tld +PASS: gdb.base/structs.exp: return foo<n>; return 1 structs-tld +PASS: gdb.base/structs.exp: value foo<n> returned; return 1 structs-tld +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: zed L<n> for finish; return 1 structs-tld +PASS: gdb.base/structs.exp: finish foo<n>; return 1 structs-tld +PASS: gdb.base/structs.exp: value foo<n> finished; return 1 structs-tld +PASS: gdb.base/structs.exp: return value known implies finish value known; return 1 structs-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 7 structs-ts-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 8 structs-ts-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 8 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ts-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-ti-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-ti-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-ti-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tl-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tl-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tl-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tll-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tll-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tll-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tf-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tf-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tld-tc +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tld-tc +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tld-tc +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 5 structs-tc-ts +PASS: gdb.base/structs.exp: p/c fun<n>(); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 6 structs-tc-ts +PASS: gdb.base/structs.exp: p/c L<n>; call 6 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ts +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-ti +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-ti +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-ti +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tl +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tl +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tc-tl +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tll +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tll +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tll +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 3 structs-tc-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 4 structs-tc-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 4 structs-tc-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-td +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tc-tld +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tc-tld +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tc-tld +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-td-tf +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-td-tf +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-td-tf +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-td-tf +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-td-tf +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-td-tf +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-td-tf +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-td-tf +PASS: gdb.base/structs.exp: set print sevenbit-strings +PASS: gdb.base/structs.exp: set print address off +PASS: gdb.base/structs.exp: set width 0 +PASS: gdb.base/structs.exp: set print elements 300 +PASS: gdb.base/structs.exp: ptype foo2; structs-tf-td +PASS: gdb.base/structs.exp: p/c fun<n>(); call 2 structs-tf-td +PASS: gdb.base/structs.exp: call Fun<n>(foo<n>); call 2 structs-tf-td +PASS: gdb.base/structs.exp: p/c L<n>; call 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for return; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> returned; return 2 structs-tf-td +PASS: gdb.base/structs.exp: advance to fun<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: zed L<n> for finish; return 2 structs-tf-td +PASS: gdb.base/structs.exp: finish foo<n>; return 2 structs-tf-td +PASS: gdb.base/structs.exp: value foo<n> finished; return 2 structs-tf-td +PASS: gdb.base/structs.exp: return value known implies finish value known; return 2 structs-tf-td +Running ./gdb.base/subst.exp ... +PASS: gdb.base/subst.exp: deactivate GDB's confirmation interface +PASS: gdb.base/subst.exp: show substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: show substitute-path, too many arguments +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path from, no rule entered yet +PASS: gdb.base/subst.exp: unset substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too many arguments +PASS: gdb.base/subst.exp: set substitute-path, too few arguments +PASS: gdb.base/subst.exp: set substitute-path, first argument is empty string +PASS: gdb.base/subst.exp: add from -> to substitution rule +PASS: gdb.base/subst.exp: add from1 -> to1 substitution rule +PASS: gdb.base/subst.exp: add source -> destination substitution rule +PASS: gdb.base/subst.exp: add depuis -> vers substitution rule +PASS: gdb.base/subst.exp: add substitution rule to empty string +PASS: gdb.base/subst.exp: show substitute-path after all paths added +PASS: gdb.base/subst.exp: show substitute-path from, after all paths added +PASS: gdb.base/subst.exp: show substitute-path depuis, after all paths added +PASS: gdb.base/subst.exp: show substitute-path garbage, after all paths added +PASS: gdb.base/subst.exp: unset substitute-path from +PASS: gdb.base/subst.exp: show substitute-path from, after unsetting it +PASS: gdb.base/subst.exp: show substitute-path after from rule removed +PASS: gdb.base/subst.exp: unset substitute-path from after the rule was removed +PASS: gdb.base/subst.exp: unset substitute-path depuis (middle of list) +PASS: gdb.base/subst.exp: show substitute-path after depuis rule removed +PASS: gdb.base/subst.exp: unset substitute-path empty (end of list) +PASS: gdb.base/subst.exp: show substitute-path after empty rule removed +PASS: gdb.base/subst.exp: remove all remaining substitution rules +PASS: gdb.base/subst.exp: show substitute-path after all remaining rules removed +Running ./gdb.base/symbol-without-target_section.exp ... +PASS: gdb.base/symbol-without-target_section.exp: add-symbol-file +PASS: gdb.base/symbol-without-target_section.exp: list main +PASS: gdb.base/symbol-without-target_section.exp: print symbol_without_target_section +Running ./gdb.base/term.exp ... +Running ./gdb.base/testenv.exp ... +Running ./gdb.base/trace-commands.exp ... +PASS: gdb.base/trace-commands.exp: show trace-commands says off +PASS: gdb.base/trace-commands.exp: source -v +PASS: gdb.base/trace-commands.exp: set trace-commands +PASS: gdb.base/trace-commands.exp: show trace-commands says on +PASS: gdb.base/trace-commands.exp: simple trace-commands test +PASS: gdb.base/trace-commands.exp: nested trace-commands test +PASS: gdb.base/trace-commands.exp: define user command +PASS: gdb.base/trace-commands.exp: nested trace-commands test with source +PASS: gdb.base/trace-commands.exp: depth resets on error part 1 +PASS: gdb.base/trace-commands.exp: depth resets on error part 2 +Running ./gdb.base/tui-layout.exp ... +PASS: gdb.base/tui-layout.exp: layout asm +Running ./gdb.base/twice.exp ... +PASS: gdb.base/twice.exp: step +Running ./gdb.base/type-opaque.exp ... +PASS: gdb.base/type-opaque.exp: opaque struct type resolving +PASS: gdb.base/type-opaque.exp: empty struct type resolving +PASS: gdb.base/type-opaque.exp: filled struct type resolving +PASS: gdb.base/type-opaque.exp: opaque union type resolving +PASS: gdb.base/type-opaque.exp: empty union type resolving +PASS: gdb.base/type-opaque.exp: filled union type resolving +Running ./gdb.base/ui-redirect.exp ... +PASS: gdb.base/ui-redirect.exp: commands +PASS: gdb.base/ui-redirect.exp: print 1 +PASS: gdb.base/ui-redirect.exp: end +PASS: gdb.base/ui-redirect.exp: set logging file /dev/null +PASS: gdb.base/ui-redirect.exp: set logging on +PASS: gdb.base/ui-redirect.exp: save breakpoints /dev/null +PASS: gdb.base/ui-redirect.exp: set logging off +PASS: gdb.base/ui-redirect.exp: help +Running ./gdb.base/unload.exp ... +PASS: gdb.base/unload.exp: pending breakpoint info before run +PASS: gdb.base/unload.exp: running program +PASS: gdb.base/unload.exp: pending breakpoint info on first run at shrfunc1 +PASS: gdb.base/unload.exp: continuing to unloaded libfile +PASS: gdb.base/unload.exp: print y from libfile +PASS: gdb.base/unload.exp: rerun to shared library breakpoint +PASS: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc1 +PASS: gdb.base/unload.exp: continuing to unloaded libfile +PASS: gdb.base/unload.exp: continue to shrfunc2 +PASS: gdb.base/unload.exp: pending breakpoint info on second run at shrfunc2 +PASS: gdb.base/unload.exp: continuing to unloaded libfile2 +PASS: gdb.base/unload.exp: print y from libfile2 +Running ./gdb.base/until.exp ... +PASS: gdb.base/until.exp: until line number +PASS: gdb.base/until.exp: malformed until +PASS: gdb.base/until.exp: until factorial, recursive function +PASS: gdb.base/until.exp: until func, not called by current frame +Running ./gdb.base/unwindonsignal.exp ... +Running ./gdb.base/valgrind-db-attach.exp ... +Running ./gdb.base/valgrind-infcall.exp ... +Running ./gdb.base/value-double-free.exp ... +PASS: gdb.base/value-double-free.exp: watch var +PASS: gdb.base/value-double-free.exp: continue +PASS: gdb.base/value-double-free.exp: print empty() +PASS: gdb.base/value-double-free.exp: help help +Running ./gdb.base/varargs.exp ... +PASS: gdb.base/varargs.exp: set print sevenbit-strings +PASS: gdb.base/varargs.exp: set print address off +PASS: gdb.base/varargs.exp: set width 0 +Running ./gdb.base/volatile.exp ... +PASS: gdb.base/volatile.exp: continue to marker1 +PASS: gdb.base/volatile.exp: up from marker1 +PASS: gdb.base/volatile.exp: ptype vox +PASS: gdb.base/volatile.exp: ptype victuals +PASS: gdb.base/volatile.exp: ptype vixen +PASS: gdb.base/volatile.exp: ptype vitriol +PASS: gdb.base/volatile.exp: ptype vellum +PASS: gdb.base/volatile.exp: ptype valve +PASS: gdb.base/volatile.exp: ptype vacuity +PASS: gdb.base/volatile.exp: ptype vertigo +PASS: gdb.base/volatile.exp: ptype vampire +PASS: gdb.base/volatile.exp: ptype viper +PASS: gdb.base/volatile.exp: ptype vigour +PASS: gdb.base/volatile.exp: ptype vapour +PASS: gdb.base/volatile.exp: ptype ventricle +PASS: gdb.base/volatile.exp: ptype vigintillion +PASS: gdb.base/volatile.exp: ptype vocation +PASS: gdb.base/volatile.exp: ptype veracity +PASS: gdb.base/volatile.exp: ptype vapidity +PASS: gdb.base/volatile.exp: ptype velocity +PASS: gdb.base/volatile.exp: ptype veneer +PASS: gdb.base/volatile.exp: ptype video +PASS: gdb.base/volatile.exp: ptype vacuum +PASS: gdb.base/volatile.exp: ptype veniality +PASS: gdb.base/volatile.exp: ptype vitality +PASS: gdb.base/volatile.exp: ptype voracity +PASS: gdb.base/volatile.exp: ptype victor +PASS: gdb.base/volatile.exp: ptype vicar +PASS: gdb.base/volatile.exp: ptype victory +PASS: gdb.base/volatile.exp: ptype vicarage +PASS: gdb.base/volatile.exp: ptype vein +PASS: gdb.base/volatile.exp: ptype vogue +PASS: gdb.base/volatile.exp: ptype cavern +PASS: gdb.base/volatile.exp: ptype coverlet +PASS: gdb.base/volatile.exp: ptype caveat +PASS: gdb.base/volatile.exp: ptype covenant +PASS: gdb.base/volatile.exp: ptype vizier +PASS: gdb.base/volatile.exp: ptype vanadium +PASS: gdb.base/volatile.exp: ptype vane +PASS: gdb.base/volatile.exp: ptype veldt +PASS: gdb.base/volatile.exp: ptype cove +PASS: gdb.base/volatile.exp: ptype cavity +PASS: gdb.base/volatile.exp: ptype vagus +PASS: gdb.base/volatile.exp: ptype vagrancy +PASS: gdb.base/volatile.exp: ptype vagary +PASS: gdb.base/volatile.exp: ptype vendor +PASS: gdb.base/volatile.exp: ptype qux2 +Running ./gdb.base/watch-cond.exp ... +PASS: gdb.base/watch-cond.exp: set write watchpoint on global variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with global expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on local variable, local condition +PASS: gdb.base/watch-cond.exp: watchpoint with local expression, local condition evaluates in correct frame +PASS: gdb.base/watch-cond.exp: set write watchpoint on global2 variable +PASS: gdb.base/watch-cond.exp: watchpoint on global2 variable triggers +PASS: gdb.base/watch-cond.exp: condition of watchpoint 2 changes +PASS: gdb.base/watch-cond.exp: watchpoint stops with untestable local expression +Running ./gdb.base/watch-cond-infcall.exp ... +PASS: gdb.base/watch-cond-infcall.exp: sw: watch var if return_1 () +PASS: gdb.base/watch-cond-infcall.exp: sw: continue +Running ./gdb.base/watch-non-mem.exp ... +PASS: gdb.base/watch-non-mem.exp: set write watchpoint on $pc +PASS: gdb.base/watch-non-mem.exp: watchpoint on $pc works +Running ./gdb.base/watchpoint-cond-gone.exp ... +PASS: gdb.base/watchpoint-cond-gone.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-cond-gone.exp: continue to breakpoint: Place to set the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Place the watchpoint +PASS: gdb.base/watchpoint-cond-gone.exp: Catch the no longer valid watchpoint +Running ./gdb.base/watchpoint-delete.exp ... +PASS: gdb.base/watchpoint-delete.exp: set can-use-hw-watchpoints 0 +PASS: gdb.base/watchpoint-delete.exp: continue to breakpoint: break-here +PASS: gdb.base/watchpoint-delete.exp: watch x +PASS: gdb.base/watchpoint-delete.exp: delete $bpnum +Running ./gdb.base/watchpoint.exp ... +PASS: gdb.base/watchpoint.exp: disable fast watches +PASS: gdb.base/watchpoint.exp: show disable fast watches +PASS: gdb.base/watchpoint.exp: set slow conditional watch +PASS: gdb.base/watchpoint.exp: trigger slow conditional watch +PASS: gdb.base/watchpoint.exp: delete watch ival3 +PASS: gdb.base/watchpoint.exp: set slow condition watch w/thread +PASS: gdb.base/watchpoint.exp: delete watch w/condition and thread +PASS: gdb.base/watchpoint.exp: rwatch disallowed when can-set-hw-watchpoints cleared +PASS: gdb.base/watchpoint.exp: set breakpoint at marker1 +PASS: gdb.base/watchpoint.exp: set breakpoint at marker2 +PASS: gdb.base/watchpoint.exp: info break in watchpoint.exp +PASS: gdb.base/watchpoint.exp: set watchpoint on ival3 +PASS: gdb.base/watchpoint.exp: watchpoint found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: run to marker1 in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: enable watchpoint +PASS: gdb.base/watchpoint.exp: break func1 +PASS: gdb.base/watchpoint.exp: set $func1_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: continue to breakpoint at func1 +PASS: gdb.base/watchpoint.exp: watchpoint hit, first time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoint.exp: delete $func1_breakpoint_number +PASS: gdb.base/watchpoint.exp: watchpoint hit, second time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoint.exp: watchpoint hit, third time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoint.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoint.exp: Watchpoint hit count is 5 +PASS: gdb.base/watchpoint.exp: continue to marker2 +PASS: gdb.base/watchpoint.exp: watchpoint disabled +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_simple_watchpoint +PASS: gdb.base/watchpoint.exp: watchpoints found in watchpoint/breakpoint table +PASS: gdb.base/watchpoint.exp: disable watchpoint in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: run to marker1 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint enabled +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, first time +PASS: gdb.base/watchpoint.exp: watchpoint hit in test_disabling_watchpoints, second time +PASS: gdb.base/watchpoint.exp: disable watchpoint #2 in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watchpoint disabled in table +PASS: gdb.base/watchpoint.exp: disabled watchpoint skipped +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_disabling_watchpoints +PASS: gdb.base/watchpoint.exp: watch ival2 +PASS: gdb.base/watchpoint.exp: break func2 if 0 +PASS: gdb.base/watchpoint.exp: p $func2_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: calling function with watchpoint enabled +PASS: gdb.base/watchpoint.exp: finish from marker1 +PASS: gdb.base/watchpoint.exp: back at main from marker1 +PASS: gdb.base/watchpoint.exp: next to `for' in watchpoint.exp +PASS: gdb.base/watchpoint.exp: until to ival1 assignment +PASS: gdb.base/watchpoint.exp: until to ival3 assignment +PASS: gdb.base/watchpoint.exp: until out of loop +PASS: gdb.base/watchpoint.exp: step to ival2 assignment +PASS: gdb.base/watchpoint.exp: watch ptr1->val +PASS: gdb.base/watchpoint.exp: break marker5 +PASS: gdb.base/watchpoint.exp: Test complex watchpoint +PASS: gdb.base/watchpoint.exp: did not trigger wrong watchpoint +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: break marker6 +PASS: gdb.base/watchpoint.exp: continue to marker6 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set local watch +PASS: gdb.base/watchpoint.exp: trigger local watch +PASS: gdb.base/watchpoint.exp: self-delete local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set partially local watch +PASS: gdb.base/watchpoint.exp: trigger1 partially local watch +PASS: gdb.base/watchpoint.exp: trigger2 partially local watch +PASS: gdb.base/watchpoint.exp: self-delete partially local watch +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func2 breakpoint here +PASS: gdb.base/watchpoint.exp: set static local watch +PASS: gdb.base/watchpoint.exp: trigger static local watch +PASS: gdb.base/watchpoint.exp: continue after trigger static local watch +PASS: gdb.base/watchpoint.exp: static local watch did not self-delete +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call +PASS: gdb.base/watchpoint.exp: trigger local watch in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch in recursive call +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: tbreak recurser +PASS: gdb.base/watchpoint.exp: cont +PASS: gdb.base/watchpoint.exp: next past local_x initialization +PASS: gdb.base/watchpoint.exp: set local watch in recursive call with explicit scope +PASS: gdb.base/watchpoint.exp: trigger local watch with explicit scope in recursive call +PASS: gdb.base/watchpoint.exp: self-delete local watch with explicit scope in recursive call (2) +PASS: gdb.base/watchpoint.exp: disable in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: continue until exit at continue to exit in test_complex_watchpoint +PASS: gdb.base/watchpoint.exp: watchpoint refused to insert on nonexistent struct member +PASS: gdb.base/watchpoint.exp: watch global_ptr +PASS: gdb.base/watchpoint.exp: watch *(int *) 0 +PASS: gdb.base/watchpoint.exp: watch -location *global_ptr +PASS: gdb.base/watchpoint.exp: watch *global_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: global_ptr next +PASS: gdb.base/watchpoint.exp: next over ptr init +PASS: gdb.base/watchpoint.exp: next over buffer set +PASS: gdb.base/watchpoint.exp: delete $global_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: watch **global_ptr_ptr +PASS: gdb.base/watchpoint.exp: set $global_ptr_ptr_breakpoint_number = $bpnum +PASS: gdb.base/watchpoint.exp: global_ptr_ptr next +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr init +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr buffer set +PASS: gdb.base/watchpoint.exp: next over global_ptr_ptr pointer advance +PASS: gdb.base/watchpoint.exp: delete $global_ptr_ptr_breakpoint_number +PASS: gdb.base/watchpoint.exp: continue to breakpoint: second x assignment +PASS: gdb.base/watchpoint.exp: watch x +PASS: gdb.base/watchpoint.exp: next after watch x +PASS: gdb.base/watchpoint.exp: delete watch x +PASS: gdb.base/watchpoint.exp: watch buf +PASS: gdb.base/watchpoint.exp: watchpoint on buf hit +PASS: gdb.base/watchpoint.exp: delete watch buf +PASS: gdb.base/watchpoint.exp: number is constant +PASS: gdb.base/watchpoint.exp: number with cast is constant +PASS: gdb.base/watchpoint.exp: marker1 is constant +PASS: gdb.base/watchpoint.exp: watch count + 6 +PASS: gdb.base/watchpoint.exp: delete watchpoint `count + 6' +PASS: gdb.base/watchpoint.exp: watch 7 + count +PASS: gdb.base/watchpoint.exp: delete watchpoint `7 + count' +PASS: gdb.base/watchpoint.exp: watch $pc +PASS: gdb.base/watchpoint.exp: disable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: reenable watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: watchpoint `$pc' is enabled +PASS: gdb.base/watchpoint.exp: delete watchpoint `$pc' +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func5 breakpoint here +PASS: gdb.base/watchpoint.exp: watch -location .x +PASS: gdb.base/watchpoint.exp: continue with watch -location +PASS: gdb.base/watchpoint.exp: delete watch -location +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func6 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo2 +PASS: gdb.base/watchpoint.exp: continue with watch foo2 +PASS: gdb.base/watchpoint.exp: delete watch foo2 +PASS: gdb.base/watchpoint.exp: continue to breakpoint: func7 breakpoint here +PASS: gdb.base/watchpoint.exp: watch foo4 +PASS: gdb.base/watchpoint.exp: continue with watch foo4 +PASS: gdb.base/watchpoint.exp: delete watch foo4 +Running ./gdb.base/watchpoint-hw.exp ... +Running ./gdb.base/watchpoint-hw-hit-once.exp ... +Running ./gdb.base/watchpoints.exp ... +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: watchpoint hit, first time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 1 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint hit, second time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 2 +PASS: gdb.base/watchpoints.exp: watchpoint ival1 hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint ival1 hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, third time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 3 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fourth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 4 +PASS: gdb.base/watchpoints.exp: watchpoint hit, fifth time +PASS: gdb.base/watchpoints.exp: Watchpoint hit count is 5 +Running ./gdb.base/watchpoint-solib.exp ... +PASS: gdb.base/watchpoint-solib.exp: set pending breakpoint +PASS: gdb.base/watchpoint-solib.exp: continue to foo +PASS: gdb.base/watchpoint-solib.exp: set watchpoint on g +PASS: gdb.base/watchpoint-solib.exp: continue to watchpoint hit +PASS: gdb.base/watchpoint-solib.exp: rerun to main +PASS: gdb.base/watchpoint-solib.exp: continue to foo again +PASS: gdb.base/watchpoint-solib.exp: continue to watchpoint hit again +Running ./gdb.base/watch-read.exp ... +Running ./gdb.base/watch_thread_num.exp ... +Running ./gdb.base/watch-vfork.exp ... +Running ./gdb.base/wchar.exp ... +PASS: gdb.base/wchar.exp: print narrow +PASS: gdb.base/wchar.exp: print single +PASS: gdb.base/wchar.exp: print simple +PASS: gdb.base/wchar.exp: print difficile +PASS: gdb.base/wchar.exp: print simple[2] +PASS: gdb.base/wchar.exp: print difficile[2] +PASS: gdb.base/wchar.exp: print repeat +PASS: gdb.base/wchar.exp: print repeat_p +PASS: gdb.base/wchar.exp: set print null on +PASS: gdb.base/wchar.exp: print repeat (print null on) +PASS: gdb.base/wchar.exp: set print elements 3 +PASS: gdb.base/wchar.exp: print repeat (print elements 3) +PASS: gdb.base/wchar.exp: print repeat_p (print elements 3) +Running ./gdb.base/whatis.exp ... +PASS: gdb.base/whatis.exp: whatis char +PASS: gdb.base/whatis.exp: whatis signed char +PASS: gdb.base/whatis.exp: whatis unsigned char +PASS: gdb.base/whatis.exp: whatis short +PASS: gdb.base/whatis.exp: whatis signed short +PASS: gdb.base/whatis.exp: whatis unsigned short +PASS: gdb.base/whatis.exp: whatis int +PASS: gdb.base/whatis.exp: whatis signed int +PASS: gdb.base/whatis.exp: whatis unsigned int +PASS: gdb.base/whatis.exp: whatis long +PASS: gdb.base/whatis.exp: whatis signed long +PASS: gdb.base/whatis.exp: whatis unsigned long +PASS: gdb.base/whatis.exp: whatis unsigned long long +PASS: gdb.base/whatis.exp: whatis float +PASS: gdb.base/whatis.exp: whatis double +PASS: gdb.base/whatis.exp: whatis char array +PASS: gdb.base/whatis.exp: whatis signed char array +PASS: gdb.base/whatis.exp: whatis unsigned char array +PASS: gdb.base/whatis.exp: whatis short array +PASS: gdb.base/whatis.exp: whatis signed short array +PASS: gdb.base/whatis.exp: whatis unsigned short array +PASS: gdb.base/whatis.exp: whatis int array +PASS: gdb.base/whatis.exp: whatis signed int array +PASS: gdb.base/whatis.exp: whatis unsigned int array +PASS: gdb.base/whatis.exp: whatis long array +PASS: gdb.base/whatis.exp: whatis signed long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis unsigned long array +PASS: gdb.base/whatis.exp: whatis float array +PASS: gdb.base/whatis.exp: whatis double array +PASS: gdb.base/whatis.exp: whatis char pointer +PASS: gdb.base/whatis.exp: whatis signed char pointer +PASS: gdb.base/whatis.exp: whatis unsigned char pointer +PASS: gdb.base/whatis.exp: whatis short pointer +PASS: gdb.base/whatis.exp: whatis signed short pointer +PASS: gdb.base/whatis.exp: whatis unsigned short pointer +PASS: gdb.base/whatis.exp: whatis int pointer +PASS: gdb.base/whatis.exp: whatis signed int pointer +PASS: gdb.base/whatis.exp: whatis unsigned int pointer +PASS: gdb.base/whatis.exp: whatis long pointer +PASS: gdb.base/whatis.exp: whatis signed long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long pointer +PASS: gdb.base/whatis.exp: whatis long long pointer +PASS: gdb.base/whatis.exp: whatis signed long long pointer +PASS: gdb.base/whatis.exp: whatis unsigned long long pointer +PASS: gdb.base/whatis.exp: whatis float pointer +PASS: gdb.base/whatis.exp: whatis double pointer +PASS: gdb.base/whatis.exp: whatis named structure +PASS: gdb.base/whatis.exp: whatis named structure using type name +PASS: gdb.base/whatis.exp: whatis unnamed structure +PASS: gdb.base/whatis.exp: whatis named union +PASS: gdb.base/whatis.exp: whatis named union using type name +PASS: gdb.base/whatis.exp: whatis unnamed union +PASS: gdb.base/whatis.exp: whatis char function +PASS: gdb.base/whatis.exp: whatis signed char function +PASS: gdb.base/whatis.exp: whatis unsigned char function +PASS: gdb.base/whatis.exp: whatis short function +PASS: gdb.base/whatis.exp: whatis signed short function +PASS: gdb.base/whatis.exp: whatis unsigned short function +PASS: gdb.base/whatis.exp: whatis int function +PASS: gdb.base/whatis.exp: whatis signed int function +PASS: gdb.base/whatis.exp: whatis unsigned int function +PASS: gdb.base/whatis.exp: whatis long function +PASS: gdb.base/whatis.exp: whatis signed long function +PASS: gdb.base/whatis.exp: whatis unsigned long function +PASS: gdb.base/whatis.exp: whatis long long function +PASS: gdb.base/whatis.exp: whatis signed long long function +PASS: gdb.base/whatis.exp: whatis unsigned long long function +PASS: gdb.base/whatis.exp: whatis float function +PASS: gdb.base/whatis.exp: whatis double function +PASS: gdb.base/whatis.exp: whatis complicated structure +PASS: gdb.base/whatis.exp: whatis complicated union +PASS: gdb.base/whatis.exp: whatis enumeration +PASS: gdb.base/whatis.exp: whatis enumeration using type name +PASS: gdb.base/whatis.exp: whatis outer structure +PASS: gdb.base/whatis.exp: whatis outer structure member +PASS: gdb.base/whatis.exp: whatis inner structure +PASS: gdb.base/whatis.exp: whatis inner structure member +PASS: gdb.base/whatis.exp: whatis inner union +PASS: gdb.base/whatis.exp: whatis inner union member +PASS: gdb.base/whatis.exp: whatis using typedef type name +PASS: gdb.base/whatis.exp: whatis applied to variable defined by typedef +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to const pointer to pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to const pointer to function +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to pointer to function returning pointer to int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function returning pointer to array +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking int,int and returning int +PASS: gdb.base/whatis.exp: whatis applied to pointer to function taking const int ptr and varargs and returning int +PASS: gdb.base/whatis.exp: whatis applied to function with types trailing 'void' +PASS: gdb.base/whatis.exp: whatis applied to function with 'void' parameter type +Running ./gdb.base/whatis-exp.exp ... +PASS: gdb.base/whatis-exp.exp: set variable x=14 +PASS: gdb.base/whatis-exp.exp: set variable y=2 +PASS: gdb.base/whatis-exp.exp: set variable z=2 +PASS: gdb.base/whatis-exp.exp: set variable w=3 +PASS: gdb.base/whatis-exp.exp: print value of x +PASS: gdb.base/whatis-exp.exp: print value of y +PASS: gdb.base/whatis-exp.exp: print value of z +PASS: gdb.base/whatis-exp.exp: print value of w +PASS: gdb.base/whatis-exp.exp: whatis value of x+y +PASS: gdb.base/whatis-exp.exp: whatis value of x-y +PASS: gdb.base/whatis-exp.exp: whatis value of x*y +PASS: gdb.base/whatis-exp.exp: whatis value of x/y +PASS: gdb.base/whatis-exp.exp: whatis value of x%y +PASS: gdb.base/whatis-exp.exp: whatis value of x=y +PASS: gdb.base/whatis-exp.exp: whatis value of x+=2 +PASS: gdb.base/whatis-exp.exp: whatis value of ++x +PASS: gdb.base/whatis-exp.exp: whatis value of --x +PASS: gdb.base/whatis-exp.exp: whatis value of x++ +PASS: gdb.base/whatis-exp.exp: whatis value of x-- +Running ./gdb.btrace/enable.exp ... +Running ./gdb.btrace/function_call_history.exp ... +Running ./gdb.btrace/instruction_history.exp ... +Running ./gdb.cell/arch.exp ... +Running ./gdb.cell/break.exp ... +Running ./gdb.cell/bt.exp ... +Running ./gdb.cell/core.exp ... +Running ./gdb.cell/data.exp ... +Running ./gdb.cell/dwarfaddr.exp ... +Running ./gdb.cell/ea-cache.exp ... +Running ./gdb.cell/ea-standalone.exp ... +Running ./gdb.cell/ea-test.exp ... +Running ./gdb.cell/fork.exp ... +Running ./gdb.cell/f-regs.exp ... +Running ./gdb.cell/gcore.exp ... +Running ./gdb.cell/mem-access.exp ... +Running ./gdb.cell/ptype.exp ... +Running ./gdb.cell/registers.exp ... +Running ./gdb.cell/sizeof.exp ... +Running ./gdb.cell/solib.exp ... +Running ./gdb.cell/solib-symbol.exp ... +Running ./gdb.cp/abstract-origin.exp ... +PASS: gdb.cp/abstract-origin.exp: continue to breakpoint: break-here +PASS: gdb.cp/abstract-origin.exp: p problem +Running ./gdb.cp/ambiguous.exp ... +Running ./gdb.cp/annota2.exp ... +Running ./gdb.cp/annota3.exp ... +Running ./gdb.cp/anon-ns.exp ... +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(int)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::doit1(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::doit1(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::one(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::one(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::doit2(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::doit2(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::two(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::two(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::doit3(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::three(char *)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::one::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::one::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::two::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::two::doit(void)' +PASS: gdb.cp/anon-ns.exp: list (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: list '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +PASS: gdb.cp/anon-ns.exp: break (anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void) +PASS: gdb.cp/anon-ns.exp: break '(anonymous namespace)::A::(anonymous namespace)::(anonymous namespace)::three::doit(void)' +Running ./gdb.cp/anon-struct.exp ... +FAIL: gdb.cp/anon-struct.exp: print type of t::t +PASS: gdb.cp/anon-struct.exp: print type of X::t2 +FAIL: gdb.cp/anon-struct.exp: print type of X::t2::t2 +FAIL: gdb.cp/anon-struct.exp: print type of t3::~t3 +Running ./gdb.cp/anon-union.exp ... +PASS: gdb.cp/anon-union.exp: set width 0 +PASS: gdb.cp/anon-union.exp: next 1 +PASS: gdb.cp/anon-union.exp: print foo 1 +PASS: gdb.cp/anon-union.exp: next 2 +PASS: gdb.cp/anon-union.exp: print foo 2 +PASS: gdb.cp/anon-union.exp: set var foo.cloth +PASS: gdb.cp/anon-union.exp: print foo 3 +PASS: gdb.cp/anon-union.exp: next 3 +PASS: gdb.cp/anon-union.exp: print foo 4 +PASS: gdb.cp/anon-union.exp: set var foo.pebble +PASS: gdb.cp/anon-union.exp: print foo 5 +PASS: gdb.cp/anon-union.exp: set var foo.qux +PASS: gdb.cp/anon-union.exp: print foo 6 +PASS: gdb.cp/anon-union.exp: set var foo.mux +PASS: gdb.cp/anon-union.exp: print foo 7 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock +PASS: gdb.cp/anon-union.exp: print foo 8 +PASS: gdb.cp/anon-union.exp: set var foo.x.rock2 +PASS: gdb.cp/anon-union.exp: print foo 9 +PASS: gdb.cp/anon-union.exp: next 4 +PASS: gdb.cp/anon-union.exp: print w 1 +PASS: gdb.cp/anon-union.exp: print z 1 +PASS: gdb.cp/anon-union.exp: next 5 +PASS: gdb.cp/anon-union.exp: print w 2 +PASS: gdb.cp/anon-union.exp: print z 2 +PASS: gdb.cp/anon-union.exp: set var z +PASS: gdb.cp/anon-union.exp: print w 3 +PASS: gdb.cp/anon-union.exp: print z 3 +Running ./gdb.cp/arg-reference.exp ... +PASS: gdb.cp/arg-reference.exp: No false reference +Running ./gdb.cp/baseenum.exp ... +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 1 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A +PASS: gdb.cp/baseenum.exp: continue to breakpoint: breakpoint 2 +PASS: gdb.cp/baseenum.exp: Print enum constant X of class A in namespace N +Running ./gdb.cp/bool.exp ... +PASS: gdb.cp/bool.exp: print return_true() +PASS: gdb.cp/bool.exp: print return_false() +Running ./gdb.cp/breakpoint.exp ... +PASS: gdb.cp/breakpoint.exp: continue to C1::Nested::foo +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method +PASS: gdb.cp/breakpoint.exp: conditional breakpoint in method 2 +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +PASS: gdb.cp/breakpoint.exp: continue to breakpoint +PASS: gdb.cp/breakpoint.exp: check the member variable +Running ./gdb.cp/bs15503.exp ... +PASS: gdb.cp/bs15503.exp: break StringTest<wchar_t>::testFunction +PASS: gdb.cp/bs15503.exp: continue to StringTest<wchar_t> +PASS: gdb.cp/bs15503.exp: continue to breakpoint: find position where blank needs to be inserted +FAIL: gdb.cp/bs15503.exp: print s.length() +FAIL: gdb.cp/bs15503.exp: print s[0] +FAIL: gdb.cp/bs15503.exp: print s[s.length()-1] +PASS: gdb.cp/bs15503.exp: print (const char *) s +FAIL: gdb.cp/bs15503.exp: print (const char *) s.substr(0,4) +FAIL: gdb.cp/bs15503.exp: print (const char *) (s=s.substr(0,4)) +Running ./gdb.cp/call-c.exp ... +PASS: gdb.cp/call-c.exp: b 43 +PASS: gdb.cp/call-c.exp: print foo(1) +PASS: gdb.cp/call-c.exp: continue to bp +PASS: gdb.cp/call-c.exp: print rf->func() +PASS: gdb.cp/call-c.exp: print handle->func() +Running ./gdb.cp/casts.exp ... +PASS: gdb.cp/casts.exp: cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: let compiler cast base class pointer to derived class pointer +PASS: gdb.cp/casts.exp: cast derived class pointer to base class pointer +PASS: gdb.cp/casts.exp: cast derived class reference to base class reference +PASS: gdb.cp/casts.exp: cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: let compiler cast base class reference to derived class reference +PASS: gdb.cp/casts.exp: basic test of const_cast +PASS: gdb.cp/casts.exp: const_cast of 0 +PASS: gdb.cp/casts.exp: basic test of static_cast +PASS: gdb.cp/casts.exp: static_cast to reference type +PASS: gdb.cp/casts.exp: basic test of reinterpret_cast +PASS: gdb.cp/casts.exp: test invalid reinterpret_cast +PASS: gdb.cp/casts.exp: reinterpret_cast to reference type +PASS: gdb.cp/casts.exp: whatis decltype(5) +PASS: gdb.cp/casts.exp: old-style cast using __typeof__ +PASS: gdb.cp/casts.exp: static_cast using __typeof__ +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof__ +PASS: gdb.cp/casts.exp: old-style cast using __typeof +PASS: gdb.cp/casts.exp: static_cast using __typeof +PASS: gdb.cp/casts.exp: reinterpret_cast using __typeof +PASS: gdb.cp/casts.exp: old-style cast using __decltype +PASS: gdb.cp/casts.exp: static_cast using __decltype +PASS: gdb.cp/casts.exp: reinterpret_cast using __decltype +PASS: gdb.cp/casts.exp: whatis __decltype(*a) +PASS: gdb.cp/casts.exp: invalid dynamic_cast +PASS: gdb.cp/casts.exp: dynamic_cast of 0 to void* +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast +PASS: gdb.cp/casts.exp: dynamic_cast upcast to unique base +PASS: gdb.cp/casts.exp: dynamic_cast simple upcast to reference +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast +PASS: gdb.cp/casts.exp: dynamic_cast simple downcast to intermediate class +PASS: gdb.cp/casts.exp: dynamic_cast to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast to reference to non-existing base +PASS: gdb.cp/casts.exp: dynamic_cast unique downcast +PASS: gdb.cp/casts.exp: dynamic_cast to sibling +Running ./gdb.cp/class2.exp ... +PASS: gdb.cp/class2.exp: set print object off +PASS: gdb.cp/class2.exp: print alpha at marker return 0 +PASS: gdb.cp/class2.exp: print beta at marker return 0 +PASS: gdb.cp/class2.exp: print * aap at marker return 0 +PASS: gdb.cp/class2.exp: print * bbp at marker return 0 +PASS: gdb.cp/class2.exp: print * abp at marker return 0, s-p-o off +PASS: gdb.cp/class2.exp: print * (B *) abp at marker return 0 +PASS: gdb.cp/class2.exp: print object with no data fields +PASS: gdb.cp/class2.exp: set print object on +PASS: gdb.cp/class2.exp: p acp +PASS: gdb.cp/class2.exp: p acp->c1 +PASS: gdb.cp/class2.exp: p acp->c2 +Running ./gdb.cp/classes.exp ... +PASS: gdb.cp/classes.exp: ptype struct default_public_struct +PASS: gdb.cp/classes.exp: ptype struct explicit_public_struct +PASS: gdb.cp/classes.exp: ptype struct protected_struct +PASS: gdb.cp/classes.exp: ptype struct private_struct +PASS: gdb.cp/classes.exp: ptype struct mixed_protection_struct +PASS: gdb.cp/classes.exp: ptype class public_class +PASS: gdb.cp/classes.exp: ptype class protected_class +PASS: gdb.cp/classes.exp: ptype class default_private_class +PASS: gdb.cp/classes.exp: ptype class explicit_private_class +PASS: gdb.cp/classes.exp: ptype class mixed_protection_class +PASS: gdb.cp/classes.exp: ptype class A +PASS: gdb.cp/classes.exp: ptype class B +PASS: gdb.cp/classes.exp: ptype class C +PASS: gdb.cp/classes.exp: ptype class D +PASS: gdb.cp/classes.exp: ptype class E +PASS: gdb.cp/classes.exp: ptype class Static +PASS: gdb.cp/classes.exp: ptype class vA +PASS: gdb.cp/classes.exp: ptype class vB +PASS: gdb.cp/classes.exp: ptype class vC +PASS: gdb.cp/classes.exp: ptype class vD +PASS: gdb.cp/classes.exp: ptype class vE +PASS: gdb.cp/classes.exp: ptype class Base1 +PASS: gdb.cp/classes.exp: ptype class Foo +PASS: gdb.cp/classes.exp: ptype class Bar +PASS: gdb.cp/classes.exp: print g_A.a +PASS: gdb.cp/classes.exp: print g_A.x +PASS: gdb.cp/classes.exp: print g_B.b +PASS: gdb.cp/classes.exp: print g_B.x +PASS: gdb.cp/classes.exp: print g_C.c +PASS: gdb.cp/classes.exp: print g_C.x +PASS: gdb.cp/classes.exp: print g_D.d +PASS: gdb.cp/classes.exp: print g_D.x +PASS: gdb.cp/classes.exp: print g_E.e +PASS: gdb.cp/classes.exp: print g_E.x +PASS: gdb.cp/classes.exp: print g_A.b +PASS: gdb.cp/classes.exp: print g_B.c +PASS: gdb.cp/classes.exp: print g_B.d +PASS: gdb.cp/classes.exp: print g_C.b +PASS: gdb.cp/classes.exp: print g_C.d +PASS: gdb.cp/classes.exp: print g_D.e +PASS: gdb.cp/classes.exp: print g_A.y +PASS: gdb.cp/classes.exp: print g_B.z +PASS: gdb.cp/classes.exp: print g_C.q +PASS: gdb.cp/classes.exp: print g_D.p +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_A) +PASS: gdb.cp/classes.exp: call class_param.Aptr_a (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aptr_x (&g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aref_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aref_x (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_A) +PASS: gdb.cp/classes.exp: call class_param.Aval_a (g_B) +PASS: gdb.cp/classes.exp: call class_param.Aval_x (g_B) +PASS: gdb.cp/classes.exp: unrelated class *param +PASS: gdb.cp/classes.exp: unrelated class ¶m +PASS: gdb.cp/classes.exp: unrelated class param +PASS: gdb.cp/classes.exp: continue to enums2(\(\)|) +PASS: gdb.cp/classes.exp: print obj_with_enum (1) +PASS: gdb.cp/classes.exp: next +PASS: gdb.cp/classes.exp: print obj_with_enum (2) +PASS: gdb.cp/classes.exp: print obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum.priv_enum +PASS: gdb.cp/classes.exp: ptype obj_with_enum +PASS: gdb.cp/classes.exp: print (ClassWithEnum::PrivEnum) 42 +PASS: gdb.cp/classes.exp: print ('ClassWithEnum::PrivEnum') 42 +PASS: gdb.cp/classes.exp: print Bar::z +PASS: gdb.cp/classes.exp: print &Foo::x +PASS: gdb.cp/classes.exp: print (int)&Foo::x +PASS: gdb.cp/classes.exp: print (int)&Bar::y == 2*sizeof(int) +PASS: gdb.cp/classes.exp: ptype Bar::z +PASS: gdb.cp/classes.exp: ptype &Bar::z +PASS: gdb.cp/classes.exp: print (int)pmi == sizeof(int) +PASS: gdb.cp/classes.exp: print Foo::st +PASS: gdb.cp/classes.exp: print bar.st +PASS: gdb.cp/classes.exp: print &foo.st +PASS: gdb.cp/classes.exp: print &Bar::st +PASS: gdb.cp/classes.exp: print *$ +PASS: gdb.cp/classes.exp: set print static-members off +PASS: gdb.cp/classes.exp: print csi without static members +PASS: gdb.cp/classes.exp: print cnsi without static members +PASS: gdb.cp/classes.exp: set print static-members on +PASS: gdb.cp/classes.exp: print csi with static members +PASS: gdb.cp/classes.exp: print cnsi with static members +PASS: gdb.cp/classes.exp: finish from marker_reg1 +PASS: gdb.cp/classes.exp: calling method for small class +FAIL: gdb.cp/classes.exp: print ctor of typedef class +FAIL: gdb.cp/classes.exp: print dtor of typedef class +PASS: gdb.cp/classes.exp: list ByAnyOtherName::times +Running ./gdb.cp/cmpd-minsyms.exp ... +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::a() const' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::b() volatile' +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at 'GDB<int>::c() const volatile' +PASS: gdb.cp/cmpd-minsyms.exp: set language c++ +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator == +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::operator==(GDB<int> const&) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<char>::harder(char) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::harder(int) +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at "int GDB<char>::even_harder<int>(char)" +PASS: gdb.cp/cmpd-minsyms.exp: setting breakpoint at GDB<int>::simple() +Running ./gdb.cp/converts.exp ... +PASS: gdb.cp/converts.exp: continue to breakpoint: end of main +PASS: gdb.cp/converts.exp: typedef to another typedef +PASS: gdb.cp/converts.exp: typedef to typedef of a typedef +PASS: gdb.cp/converts.exp: Pointer-to-pointer-to-pointer derived to Pointer-to-pointer-to-pointer base. +PASS: gdb.cp/converts.exp: pointer to pointer +PASS: gdb.cp/converts.exp: pointer to array +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to pointer of wrong type +PASS: gdb.cp/converts.exp: pointer to ancestor pointer +PASS: gdb.cp/converts.exp: pointer to void pointer +PASS: gdb.cp/converts.exp: pointer to void pointer pointer +PASS: gdb.cp/converts.exp: pointer to boolean +PASS: gdb.cp/converts.exp: pointer to long int +PASS: gdb.cp/converts.exp: pointer pointer to void pointer +PASS: gdb.cp/converts.exp: pointer pointer to pointer pointer +PASS: gdb.cp/converts.exp: pointer pointer to array of arrays +PASS: gdb.cp/converts.exp: pointer pointer to array of pointers +PASS: gdb.cp/converts.exp: pointer pointer to array of wrong pointers +PASS: gdb.cp/converts.exp: check all parameters for badness +PASS: gdb.cp/converts.exp: null pointer conversion +PASS: gdb.cp/converts.exp: p foo3_1 (0, 1) +PASS: gdb.cp/converts.exp: p foo3_1 (0, (const char**) 1) +PASS: gdb.cp/converts.exp: p foo3_2 (0, 0) +PASS: gdb.cp/converts.exp: p foo3_2 (0, (char const**) 0) +PASS: gdb.cp/converts.exp: p foo1_7(0) +PASS: gdb.cp/converts.exp: p foo1_7(integer) +PASS: gdb.cp/converts.exp: p foo1_7(long_int) +PASS: gdb.cp/converts.exp: p foo1_7(*a) +PASS: gdb.cp/converts.exp: p foo1_7(MY_A) +PASS: gdb.cp/converts.exp: p foo1_7(&foo1_7) +PASS: gdb.cp/converts.exp: p foo1_7(&A::member_) +PASS: gdb.cp/converts.exp: p foo1_7(a) +PASS: gdb.cp/converts.exp: p foo1_7(fp) +PASS: gdb.cp/converts.exp: p foo1_7(dp) +PASS: gdb.cp/converts.exp: p foo1_7(-1.23) +PASS: gdb.cp/converts.exp: p foo1_7(ta) +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: set check type off +PASS: gdb.cp/converts.exp: show check type +PASS: gdb.cp/converts.exp: p foo1_type_check (123) +PASS: gdb.cp/converts.exp: p foo2_type_check (0, 1) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 0) +PASS: gdb.cp/converts.exp: p foo2_type_check (1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 0, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 0, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (0, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 0) +PASS: gdb.cp/converts.exp: p foo3_type_check (1, 1, 1) +PASS: gdb.cp/converts.exp: p foo3_2 (1,1) +Running ./gdb.cp/cpcompletion.exp ... +PASS: gdb.cp/cpcompletion.exp: complete class methods +PASS: gdb.cp/cpcompletion.exp: complete class methods beginning with F +PASS: gdb.cp/cpcompletion.exp: complete p foo1.g +PASS: gdb.cp/cpcompletion.exp: complete p foo1.base +PASS: gdb.cp/cpcompletion.exp: complete p foo1.Fo +PASS: gdb.cp/cpcompletion.exp: complete p a.g +Running ./gdb.cp/cpexprs.exp ... +PASS: gdb.cp/cpexprs.exp: set listsize 1 +PASS: gdb.cp/cpexprs.exp: print base1::a_function +FAIL: gdb.cp/cpexprs.exp: print base1::base1(int) +FAIL: gdb.cp/cpexprs.exp: print base1::base1(void) +PASS: gdb.cp/cpexprs.exp: print base2::a_function +FAIL: gdb.cp/cpexprs.exp: print base2::base2 +FAIL: gdb.cp/cpexprs.exp: print base::base(int) +FAIL: gdb.cp/cpexprs.exp: print base::base(void) +PASS: gdb.cp/cpexprs.exp: print base::operator char* +PASS: gdb.cp/cpexprs.exp: print base::operator delete +PASS: gdb.cp/cpexprs.exp: print base::operator delete[] +PASS: gdb.cp/cpexprs.exp: print base::operator fluff* +PASS: gdb.cp/cpexprs.exp: print base::operator fluff** +PASS: gdb.cp/cpexprs.exp: print base::operator int +PASS: gdb.cp/cpexprs.exp: print base::operator new +PASS: gdb.cp/cpexprs.exp: print base::operator new[] +PASS: gdb.cp/cpexprs.exp: print base::operator! +PASS: gdb.cp/cpexprs.exp: print base::operator!= +PASS: gdb.cp/cpexprs.exp: print base::operator% +PASS: gdb.cp/cpexprs.exp: print base::operator%= +PASS: gdb.cp/cpexprs.exp: print base::operator& +PASS: gdb.cp/cpexprs.exp: print base::operator&& +PASS: gdb.cp/cpexprs.exp: print base::operator&= +PASS: gdb.cp/cpexprs.exp: print base::operator() +PASS: gdb.cp/cpexprs.exp: print base::operator* +PASS: gdb.cp/cpexprs.exp: print base::operator*= +PASS: gdb.cp/cpexprs.exp: print base::operator+ +PASS: gdb.cp/cpexprs.exp: print base::operator++ +PASS: gdb.cp/cpexprs.exp: print base::operator+= +PASS: gdb.cp/cpexprs.exp: print base::operator- +PASS: gdb.cp/cpexprs.exp: print base::operator-- +PASS: gdb.cp/cpexprs.exp: print base::operator-= +PASS: gdb.cp/cpexprs.exp: print base::operator/ +PASS: gdb.cp/cpexprs.exp: print base::operator/= +PASS: gdb.cp/cpexprs.exp: print base::operator< +PASS: gdb.cp/cpexprs.exp: print base::operator<< +PASS: gdb.cp/cpexprs.exp: print base::operator<<= +PASS: gdb.cp/cpexprs.exp: print base::operator<= +PASS: gdb.cp/cpexprs.exp: print base::operator= +PASS: gdb.cp/cpexprs.exp: print base::operator== +PASS: gdb.cp/cpexprs.exp: print base::operator> +PASS: gdb.cp/cpexprs.exp: print base::operator>= +PASS: gdb.cp/cpexprs.exp: print base::operator>> +PASS: gdb.cp/cpexprs.exp: print base::operator>>= +PASS: gdb.cp/cpexprs.exp: print base::operator[] +PASS: gdb.cp/cpexprs.exp: print base::operator^ +PASS: gdb.cp/cpexprs.exp: print base::operator^= +PASS: gdb.cp/cpexprs.exp: print base::operator| +PASS: gdb.cp/cpexprs.exp: print base::operator|= +PASS: gdb.cp/cpexprs.exp: print base::operator|| +PASS: gdb.cp/cpexprs.exp: print base::operator~ +PASS: gdb.cp/cpexprs.exp: print base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: print base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: print base::overload(int) const +PASS: gdb.cp/cpexprs.exp: print base::overload(long) const +PASS: gdb.cp/cpexprs.exp: print base::overload(short) const +PASS: gdb.cp/cpexprs.exp: print base::overload(void) const +FAIL: gdb.cp/cpexprs.exp: print base::~base +PASS: gdb.cp/cpexprs.exp: print derived::a_function +FAIL: gdb.cp/cpexprs.exp: print derived::derived +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: print flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: print flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: print policy1::function +FAIL: gdb.cp/cpexprs.exp: print policy1::policy +PASS: gdb.cp/cpexprs.exp: print policy2::function +FAIL: gdb.cp/cpexprs.exp: print policy2::policy +PASS: gdb.cp/cpexprs.exp: print policy3::function +FAIL: gdb.cp/cpexprs.exp: print policy3::policy +PASS: gdb.cp/cpexprs.exp: print policy4::function +FAIL: gdb.cp/cpexprs.exp: print policy4::policy +PASS: gdb.cp/cpexprs.exp: print policyd1::function +FAIL: gdb.cp/cpexprs.exp: print policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd2::function +FAIL: gdb.cp/cpexprs.exp: print policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd3::function +FAIL: gdb.cp/cpexprs.exp: print policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd4::function +FAIL: gdb.cp/cpexprs.exp: print policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd5::function +FAIL: gdb.cp/cpexprs.exp: print policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<int, operation_1<int> >::~policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::function +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::policyd +FAIL: gdb.cp/cpexprs.exp: print policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: print tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: print tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: print test_function +PASS: gdb.cp/cpexprs.exp: list base1::a_function +PASS: gdb.cp/cpexprs.exp: list base1::base1(int) +PASS: gdb.cp/cpexprs.exp: list base1::base1(void) +PASS: gdb.cp/cpexprs.exp: list base2::a_function +PASS: gdb.cp/cpexprs.exp: list base2::base2 +PASS: gdb.cp/cpexprs.exp: list base::base(int) +PASS: gdb.cp/cpexprs.exp: list base::base(void) +PASS: gdb.cp/cpexprs.exp: list base::operator char* +PASS: gdb.cp/cpexprs.exp: list base::operator delete +PASS: gdb.cp/cpexprs.exp: list base::operator delete[] +PASS: gdb.cp/cpexprs.exp: list base::operator fluff* +PASS: gdb.cp/cpexprs.exp: list base::operator fluff** +PASS: gdb.cp/cpexprs.exp: list base::operator int +PASS: gdb.cp/cpexprs.exp: list base::operator new +PASS: gdb.cp/cpexprs.exp: list base::operator new[] +PASS: gdb.cp/cpexprs.exp: list base::operator! +PASS: gdb.cp/cpexprs.exp: list base::operator!= +PASS: gdb.cp/cpexprs.exp: list base::operator% +PASS: gdb.cp/cpexprs.exp: list base::operator%= +PASS: gdb.cp/cpexprs.exp: list base::operator& +PASS: gdb.cp/cpexprs.exp: list base::operator&& +PASS: gdb.cp/cpexprs.exp: list base::operator&= +PASS: gdb.cp/cpexprs.exp: list base::operator() +PASS: gdb.cp/cpexprs.exp: list base::operator* +PASS: gdb.cp/cpexprs.exp: list base::operator*= +PASS: gdb.cp/cpexprs.exp: list base::operator+ +PASS: gdb.cp/cpexprs.exp: list base::operator++ +PASS: gdb.cp/cpexprs.exp: list base::operator+= +PASS: gdb.cp/cpexprs.exp: list base::operator- +PASS: gdb.cp/cpexprs.exp: list base::operator-- +PASS: gdb.cp/cpexprs.exp: list base::operator-= +PASS: gdb.cp/cpexprs.exp: list base::operator/ +PASS: gdb.cp/cpexprs.exp: list base::operator/= +PASS: gdb.cp/cpexprs.exp: list base::operator< +PASS: gdb.cp/cpexprs.exp: list base::operator<< +PASS: gdb.cp/cpexprs.exp: list base::operator<<= +PASS: gdb.cp/cpexprs.exp: list base::operator<= +PASS: gdb.cp/cpexprs.exp: list base::operator= +PASS: gdb.cp/cpexprs.exp: list base::operator== +PASS: gdb.cp/cpexprs.exp: list base::operator> +PASS: gdb.cp/cpexprs.exp: list base::operator>= +PASS: gdb.cp/cpexprs.exp: list base::operator>> +PASS: gdb.cp/cpexprs.exp: list base::operator>>= +PASS: gdb.cp/cpexprs.exp: list base::operator[] +PASS: gdb.cp/cpexprs.exp: list base::operator^ +PASS: gdb.cp/cpexprs.exp: list base::operator^= +PASS: gdb.cp/cpexprs.exp: list base::operator| +PASS: gdb.cp/cpexprs.exp: list base::operator|= +PASS: gdb.cp/cpexprs.exp: list base::operator|| +PASS: gdb.cp/cpexprs.exp: list base::operator~ +PASS: gdb.cp/cpexprs.exp: list base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: list base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: list base::overload(int) const +PASS: gdb.cp/cpexprs.exp: list base::overload(long) const +PASS: gdb.cp/cpexprs.exp: list base::overload(short) const +PASS: gdb.cp/cpexprs.exp: list base::overload(void) const +PASS: gdb.cp/cpexprs.exp: list base::~base +PASS: gdb.cp/cpexprs.exp: list derived::a_function +PASS: gdb.cp/cpexprs.exp: list derived::derived +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: list flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: list flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: list policy1::function +PASS: gdb.cp/cpexprs.exp: list policy1::policy +PASS: gdb.cp/cpexprs.exp: list policy2::function +PASS: gdb.cp/cpexprs.exp: list policy2::policy +PASS: gdb.cp/cpexprs.exp: list policy3::function +PASS: gdb.cp/cpexprs.exp: list policy3::policy +PASS: gdb.cp/cpexprs.exp: list policy4::function +PASS: gdb.cp/cpexprs.exp: list policy4::policy +PASS: gdb.cp/cpexprs.exp: list policyd1::function +PASS: gdb.cp/cpexprs.exp: list policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd2::function +PASS: gdb.cp/cpexprs.exp: list policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd3::function +PASS: gdb.cp/cpexprs.exp: list policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd4::function +PASS: gdb.cp/cpexprs.exp: list policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd5::function +PASS: gdb.cp/cpexprs.exp: list policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: list policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: list policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: list tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: list tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: list test_function +PASS: gdb.cp/cpexprs.exp: continue to base1::a_function +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(int) +PASS: gdb.cp/cpexprs.exp: continue to base1::base1(void) +PASS: gdb.cp/cpexprs.exp: continue to base2::a_function +PASS: gdb.cp/cpexprs.exp: continue to base2::base2 +PASS: gdb.cp/cpexprs.exp: continue to base::base(int) +PASS: gdb.cp/cpexprs.exp: continue to base::base(void) +PASS: gdb.cp/cpexprs.exp: continue to base::operator char* +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete +PASS: gdb.cp/cpexprs.exp: continue to base::operator delete[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff* +PASS: gdb.cp/cpexprs.exp: continue to base::operator fluff** +PASS: gdb.cp/cpexprs.exp: continue to base::operator int +PASS: gdb.cp/cpexprs.exp: continue to base::operator new +PASS: gdb.cp/cpexprs.exp: continue to base::operator new[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator! +PASS: gdb.cp/cpexprs.exp: continue to base::operator!= +PASS: gdb.cp/cpexprs.exp: continue to base::operator% +PASS: gdb.cp/cpexprs.exp: continue to base::operator%= +PASS: gdb.cp/cpexprs.exp: continue to base::operator& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&& +PASS: gdb.cp/cpexprs.exp: continue to base::operator&= +PASS: gdb.cp/cpexprs.exp: continue to base::operator() +PASS: gdb.cp/cpexprs.exp: continue to base::operator* +PASS: gdb.cp/cpexprs.exp: continue to base::operator*= +PASS: gdb.cp/cpexprs.exp: continue to base::operator+ +PASS: gdb.cp/cpexprs.exp: continue to base::operator++ +PASS: gdb.cp/cpexprs.exp: continue to base::operator+= +PASS: gdb.cp/cpexprs.exp: continue to base::operator- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-- +PASS: gdb.cp/cpexprs.exp: continue to base::operator-= +PASS: gdb.cp/cpexprs.exp: continue to base::operator/ +PASS: gdb.cp/cpexprs.exp: continue to base::operator/= +PASS: gdb.cp/cpexprs.exp: continue to base::operator< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<< +PASS: gdb.cp/cpexprs.exp: continue to base::operator<<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator<= +PASS: gdb.cp/cpexprs.exp: continue to base::operator= +PASS: gdb.cp/cpexprs.exp: continue to base::operator== +PASS: gdb.cp/cpexprs.exp: continue to base::operator> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator>> +PASS: gdb.cp/cpexprs.exp: continue to base::operator>>= +PASS: gdb.cp/cpexprs.exp: continue to base::operator[] +PASS: gdb.cp/cpexprs.exp: continue to base::operator^ +PASS: gdb.cp/cpexprs.exp: continue to base::operator^= +PASS: gdb.cp/cpexprs.exp: continue to base::operator| +PASS: gdb.cp/cpexprs.exp: continue to base::operator|= +PASS: gdb.cp/cpexprs.exp: continue to base::operator|| +PASS: gdb.cp/cpexprs.exp: continue to base::operator~ +PASS: gdb.cp/cpexprs.exp: continue to base::overload(base&) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(char*) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(int) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(long) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(short) const +PASS: gdb.cp/cpexprs.exp: continue to base::overload(void) const +PASS: gdb.cp/cpexprs.exp: continue to base::~base +PASS: gdb.cp/cpexprs.exp: continue to derived::a_function +PASS: gdb.cp/cpexprs.exp: continue to derived::derived +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, char, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, long, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, int, short, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, char> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to flubber<int, int, short, short, int> +PASS: gdb.cp/cpexprs.exp: continue to flubber<long, short, long, short, long> +PASS: gdb.cp/cpexprs.exp: continue to flubber<short, int, short, int, short> +PASS: gdb.cp/cpexprs.exp: continue to policy1::function +PASS: gdb.cp/cpexprs.exp: continue to policy1::policy +PASS: gdb.cp/cpexprs.exp: continue to policy2::function +PASS: gdb.cp/cpexprs.exp: continue to policy2::policy +PASS: gdb.cp/cpexprs.exp: continue to policy3::function +PASS: gdb.cp/cpexprs.exp: continue to policy3::policy +PASS: gdb.cp/cpexprs.exp: continue to policy4::function +PASS: gdb.cp/cpexprs.exp: continue to policy4::policy +PASS: gdb.cp/cpexprs.exp: continue to policyd1::function +PASS: gdb.cp/cpexprs.exp: continue to policyd1::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd1::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd1::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd2::function +PASS: gdb.cp/cpexprs.exp: continue to policyd2::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd2::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd2::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd3::function +PASS: gdb.cp/cpexprs.exp: continue to policyd3::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd3::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd3::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd4::function +PASS: gdb.cp/cpexprs.exp: continue to policyd4::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd4::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd4::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd5::function +PASS: gdb.cp/cpexprs.exp: continue to policyd5::policyd +FAIL: gdb.cp/cpexprs.exp: setting breakpoint at policyd5::~policyd +FAIL: gdb.cp/cpexprs.exp: continue to policyd5::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<base, operation_1<base> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<char, operation_1<char> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<int, operation_1<int> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<long, operation_1<long> >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::function +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::policyd +PASS: gdb.cp/cpexprs.exp: continue to policyd<tclass<int>, operation_1<tclass<int> > >::~policyd +PASS: gdb.cp/cpexprs.exp: continue to tclass<base>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<char>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<int>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<long>::do_something +PASS: gdb.cp/cpexprs.exp: continue to tclass<short>::do_something +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int)' +PASS: gdb.cp/cpexprs.exp: p CV::m(int) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p 'CV::m(int) const volatile' +KFAIL: gdb.cp/cpexprs.exp: p CV::m(int) const volatile (PRMS: c++/14186) +PASS: gdb.cp/cpexprs.exp: p CV_f(int) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::t) +PASS: gdb.cp/cpexprs.exp: p CV_f(CV::i) +Running ./gdb.cp/cplabel.exp ... +PASS: gdb.cp/cplabel.exp: break foo::bar:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::bar:get_out_of_here +PASS: gdb.cp/cplabel.exp: break foo::baz:to_the_top +PASS: gdb.cp/cplabel.exp: break foo::baz:get_out_of_here +Running ./gdb.cp/cplusfuncs.exp ... +PASS: gdb.cp/cplusfuncs.exp: set width 0 +PASS: gdb.cp/cplusfuncs.exp: set language c++ +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_comma +PASS: gdb.cp/cplusfuncs.exp: detect dm_operator_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_char_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_foo_ref +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_int_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_int +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_void_star +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_short +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_unsigned_long +PASS: gdb.cp/cplusfuncs.exp: detect dm_type_typedef +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(void)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(signed char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned char)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned short)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(unsigned long)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(float)' +PASS: gdb.cp/cplusfuncs.exp: print &'overload1arg(double)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &'overloadargs(int, int, int, int, int, int, int, int, int, int, int)' +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator!(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator++(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator*=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator%=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator>>=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator|=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator,(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator+(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator==(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator||(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator~(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator--(int) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator-=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator/=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator<<=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator&=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator^=(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator->*(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator[](foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator()(foo&) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator new[] +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator delete(void*) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator int(void) +PASS: gdb.cp/cplusfuncs.exp: print &foo::operator char*(void) +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc1 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc2 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc3 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc4 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc5 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc6 +PASS: gdb.cp/cplusfuncs.exp: print &hairyfunc7 +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator!(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator++(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\*=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator%=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator>>=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator|=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator,(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator+(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator==(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator||(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator~(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator--(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator-=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator/=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator<<=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator&=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator^=(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator->\*(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator\[\](" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator new(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator delete(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator int(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator()(" +PASS: gdb.cp/cplusfuncs.exp: info function for "operator char\*(" +PASS: gdb.cp/cplusfuncs.exp: list foo::operator int* +Running ./gdb.cp/cp-relocate.exp ... +PASS: gdb.cp/cp-relocate.exp: info functions +PASS: gdb.cp/cp-relocate.exp: get address of func<1>(int) +PASS: gdb.cp/cp-relocate.exp: get address of func<2>(int) +PASS: gdb.cp/cp-relocate.exp: get address of caller +PASS: gdb.cp/cp-relocate.exp: C++ functions have different addresses +PASS: gdb.cp/cp-relocate.exp: info file +PASS: gdb.cp/cp-relocate.exp: add-symbol-file cp-relocate.o +PASS: gdb.cp/cp-relocate.exp: break *func<1>(int) +PASS: gdb.cp/cp-relocate.exp: break *func<2>(int) +Running ./gdb.cp/ctti.exp ... +PASS: gdb.cp/ctti.exp: continue to breakpoint: marker add1 +PASS: gdb.cp/ctti.exp: print c +PASS: gdb.cp/ctti.exp: print f +PASS: gdb.cp/ctti.exp: print i +Running ./gdb.cp/debug-expr.exp ... +PASS: gdb.cp/debug-expr.exp: set language c++ +PASS: gdb.cp/debug-expr.exp: set debug expression 1 +PASS: gdb.cp/debug-expr.exp: print static_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print reinterpret_cast<void*>(0) +PASS: gdb.cp/debug-expr.exp: print dynamic_cast<void*>(0) +Running ./gdb.cp/demangle.exp ... +PASS: gdb.cp/demangle.exp: set language c++ +PASS: gdb.cp/demangle.exp: set width 0 +PASS: gdb.cp/demangle.exp: lucid: set demangle-style +PASS: gdb.cp/demangle.exp: lucid: check demangling style +PASS: gdb.cp/demangle.exp: lucid: WS__FR7istream +PASS: gdb.cp/demangle.exp: lucid: __aa__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __aad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ad__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __adv__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aer__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __als__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amd__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ami__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __amu__7complexF7complex +PASS: gdb.cp/demangle.exp: lucid: __aor__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __apl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ars__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __as__18istream_withassignFR7istream +PASS: gdb.cp/demangle.exp: lucid: __as__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __as__3iosFR3ios +PASS: gdb.cp/demangle.exp: lucid: __cl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __cm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __co__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPc +PASS: gdb.cp/demangle.exp: lucid: __ct__10istrstreamFPci +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFPciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__10ostrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __ct__10smanip_intFPFR3iosi_R3iosi +PASS: gdb.cp/demangle.exp: lucid: __ct__11c_exceptionFPcRC7complexT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__11fstreambaseFv +PASS: gdb.cp/demangle.exp: lucid: __ct__11smanip_longFPFR3iosl_R3iosl +PASS: gdb.cp/demangle.exp: lucid: __ct__11stdiostreamFP4FILE +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPFl_PvPFPv_v +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPUciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFi +PASS: gdb.cp/demangle.exp: lucid: __ct__12strstreambufFv +PASS: gdb.cp/demangle.exp: lucid: __ct__13strstreambaseFPciT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiN31 +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiPCc +PASS: gdb.cp/demangle.exp: lucid: __ct__3fooFiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: __ct__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7filebufFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__7fstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFP9streambufiP7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__7istreamFiT1P7ostream +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ct__7ostreamFiPc +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: __ct__8ifstreamFiPcT1 +PASS: gdb.cp/demangle.exp: lucid: __ct__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __ct__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dl__3fooSFPv +PASS: gdb.cp/demangle.exp: lucid: __dl__FPv +PASS: gdb.cp/demangle.exp: lucid: __dt__10istrstreamFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q23foo3barFv +PASS: gdb.cp/demangle.exp: lucid: __dt__Q33foo3bar4bellFv +PASS: gdb.cp/demangle.exp: lucid: __dv__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __dv__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __er__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ge__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __gt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __le__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPCc +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFPv +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFUl +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFd +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFf +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFi +PASS: gdb.cp/demangle.exp: lucid: __ls__7ostreamFl +PASS: gdb.cp/demangle.exp: lucid: __ls__FR7ostream7complex +PASS: gdb.cp/demangle.exp: lucid: __lt__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __md__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __mi__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __ml__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: __mm__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __ne__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __nt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __nw__3fooSFi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUi +PASS: gdb.cp/demangle.exp: lucid: __nw__FUiPv +PASS: gdb.cp/demangle.exp: lucid: __oo__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __opPc__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __opi__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __or__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pl__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __pp__3fooFi +PASS: gdb.cp/demangle.exp: lucid: __pt__3fooFv +PASS: gdb.cp/demangle.exp: lucid: __rm__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPFR7istream_R7istream +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPUc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRUs +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRd +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRf +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRi +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRl +PASS: gdb.cp/demangle.exp: lucid: __rs__7istreamFRs +PASS: gdb.cp/demangle.exp: lucid: __rs__FR7istreamR7complex +PASS: gdb.cp/demangle.exp: lucid: __vc__3fooFR3foo +PASS: gdb.cp/demangle.exp: lucid: __vtbl__10istrstream +PASS: gdb.cp/demangle.exp: lucid: __vtbl__17ostream__iostream__19iostream_withassign +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios +PASS: gdb.cp/demangle.exp: lucid: __vtbl__3ios__13strstreambase +KFAIL: gdb.cp/demangle.exp: lucid: __vtbl__3foo__vt_cc_main_ (PRMS: gdb/945) +PASS: gdb.cp/demangle.exp: lucid: abs__F7complex +PASS: gdb.cp/demangle.exp: lucid: allocate__9streambufFv +PASS: gdb.cp/demangle.exp: lucid: attach__11fstreambaseFi +PASS: gdb.cp/demangle.exp: lucid: bitalloc__3iosSFv +PASS: gdb.cp/demangle.exp: lucid: chr__FiT1 +PASS: gdb.cp/demangle.exp: lucid: complex_error__FR11c_exception +PASS: gdb.cp/demangle.exp: lucid: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: lucid: complicated_put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: conv10__FlPc +PASS: gdb.cp/demangle.exp: lucid: conv16__FUlPc +PASS: gdb.cp/demangle.exp: lucid: dec__FR3ios +PASS: gdb.cp/demangle.exp: lucid: dec__Fli +PASS: gdb.cp/demangle.exp: lucid: dofield__FP7ostreamPciT2T3 +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFl +PASS: gdb.cp/demangle.exp: lucid: flags__3iosFv +PASS: gdb.cp/demangle.exp: lucid: foo__FiN31 +PASS: gdb.cp/demangle.exp: lucid: foo__FiR3fooT1T2T1T2 +PASS: gdb.cp/demangle.exp: lucid: foo___3barFl +PASS: gdb.cp/demangle.exp: lucid: form__FPCce +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: get__7istreamFR9streambufc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: get_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPUcic +PASS: gdb.cp/demangle.exp: lucid: getline__7istreamFPcic +PASS: gdb.cp/demangle.exp: lucid: ignore__7istreamFiT1 +PASS: gdb.cp/demangle.exp: lucid: init__12strstreambufFPciT1 +PASS: gdb.cp/demangle.exp: lucid: init__3iosFP9streambuf +PASS: gdb.cp/demangle.exp: lucid: initcount__13Iostream_init +PASS: gdb.cp/demangle.exp: lucid: ipfx__7istreamFi +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFUc +PASS: gdb.cp/demangle.exp: lucid: ls_complicated__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: open__11fstreambaseFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: open__7filebufFPCciT2 +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FSc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__FUs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fc +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fd +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Ff +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fi +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fl +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fs +PASS: gdb.cp/demangle.exp: lucid: overload1arg__Fv +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN21 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN31 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN41 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN51 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN61 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN71 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN81 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiN91N11 +PASS: gdb.cp/demangle.exp: lucid: overloadargs__FiT1 +PASS: gdb.cp/demangle.exp: lucid: polar__FdT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexT1 +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexd +PASS: gdb.cp/demangle.exp: lucid: pow__F7complexi +PASS: gdb.cp/demangle.exp: lucid: pow__Fd7complex +PASS: gdb.cp/demangle.exp: lucid: pstart__FPciT2 +PASS: gdb.cp/demangle.exp: lucid: put__7ostreamFc +PASS: gdb.cp/demangle.exp: lucid: read__7istreamFPci +PASS: gdb.cp/demangle.exp: lucid: resetiosflags__FR3iosl +PASS: gdb.cp/demangle.exp: lucid: restore_errno__FRi +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRUc +PASS: gdb.cp/demangle.exp: lucid: rs_complicated__7istreamFRc +PASS: gdb.cp/demangle.exp: lucid: seekg__7istreamFl8seek_dir +PASS: gdb.cp/demangle.exp: lucid: seekoff__12strstreambufFl8seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri +PASS: gdb.cp/demangle.exp: lucid: seekpos__9streambufFli +PASS: gdb.cp/demangle.exp: lucid: set_new_handler__FPFv_v +PASS: gdb.cp/demangle.exp: lucid: setb__9streambufFPcT1i +PASS: gdb.cp/demangle.exp: lucid: setb__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setbuf__11fstreambaseFPci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPUci +PASS: gdb.cp/demangle.exp: lucid: setbuf__9streambufFPciT2 +PASS: gdb.cp/demangle.exp: lucid: setf__3iosFlT1 +PASS: gdb.cp/demangle.exp: lucid: setfill__FR3iosi +PASS: gdb.cp/demangle.exp: lucid: setg__9streambufFPcN21 +PASS: gdb.cp/demangle.exp: lucid: setp__9streambufFPcT1 +PASS: gdb.cp/demangle.exp: lucid: sputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: str__FPCci +PASS: gdb.cp/demangle.exp: lucid: tie__3iosFP7ostream +PASS: gdb.cp/demangle.exp: lucid: uconv10__FUlPc +PASS: gdb.cp/demangle.exp: lucid: write__7ostreamFPCci +PASS: gdb.cp/demangle.exp: lucid: xget__7istreamFPc +PASS: gdb.cp/demangle.exp: lucid: xsgetn__9streambufFPci +PASS: gdb.cp/demangle.exp: lucid: xsputn__9streambufFPCci +PASS: gdb.cp/demangle.exp: lucid: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: set demangle-style +PASS: gdb.cp/demangle.exp: gnu: check demangling style +PASS: gdb.cp/demangle.exp: gnu: Abort__FP6EditoriPCc +PASS: gdb.cp/demangle.exp: gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue +PASS: gdb.cp/demangle.exp: gnu: Append__15NameChooserViewPCc +PASS: gdb.cp/demangle.exp: gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic +PASS: gdb.cp/demangle.exp: gnu: AtEnd__13ivRubberGroup +PASS: gdb.cp/demangle.exp: gnu: BgFilter__9ivTSolverP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: BitPatterntoa__FRC10BitPatternccc +PASS: gdb.cp/demangle.exp: gnu: Check__6UArrayi +PASS: gdb.cp/demangle.exp: gnu: CoreConstDecls__8TextCodeR7ostream +PASS: gdb.cp/demangle.exp: gnu: Detach__8StateVarP12StateVarView +PASS: gdb.cp/demangle.exp: gnu: Done__9ComponentG8Iterator +PASS: gdb.cp/demangle.exp: gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii +PASS: gdb.cp/demangle.exp: gnu: Edit__12StringEditorPCcii +PASS: gdb.cp/demangle.exp: gnu: Effect__11RelateManipR7ivEvent +PASS: gdb.cp/demangle.exp: gnu: FilterName__FPCc +PASS: gdb.cp/demangle.exp: gnu: Filter__6PSTextPCci +PASS: gdb.cp/demangle.exp: gnu: FindColor__7CatalogPCciii +PASS: gdb.cp/demangle.exp: gnu: FindFixed__FRP4CNetP4CNet +PASS: gdb.cp/demangle.exp: gnu: FindFont__7CatalogPCcN21 +PASS: gdb.cp/demangle.exp: gnu: Fix48_abort__FR8twolongs +PASS: gdb.cp/demangle.exp: gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2 +PASS: gdb.cp/demangle.exp: gnu: GetBgColor__C9ivPainter +PASS: gdb.cp/demangle.exp: gnu: Iisdouble__FPC6IntRep +PASS: gdb.cp/demangle.exp: gnu: InsertBody__15H_PullrightMenuii +PASS: gdb.cp/demangle.exp: gnu: InsertCharacter__9TextManipc +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1 +PASS: gdb.cp/demangle.exp: gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi +PASS: gdb.cp/demangle.exp: gnu: IsADirectory__FPCcR4stat +PASS: gdb.cp/demangle.exp: gnu: IsAGroup__FP11GraphicViewP11GraphicComp +PASS: gdb.cp/demangle.exp: gnu: IsA__10ButtonCodeUl +PASS: gdb.cp/demangle.exp: gnu: ReadName__FR7istreamPc +PASS: gdb.cp/demangle.exp: gnu: Redraw__13StringBrowseriiii +PASS: gdb.cp/demangle.exp: gnu: Rotate__13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Rotated__C13ivTransformerf +PASS: gdb.cp/demangle.exp: gnu: Round__Ff +PASS: gdb.cp/demangle.exp: gnu: SetExport__16MemberSharedNameUi +PASS: gdb.cp/demangle.exp: gnu: Set__14ivControlState13ControlStatusUi +PASS: gdb.cp/demangle.exp: gnu: Set__5DFacePcii +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2 +PASS: gdb.cp/demangle.exp: gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement +PASS: gdb.cp/demangle.exp: gnu: VOrder__9ivTSolverUiRP12ivInteractorT2 +PASS: gdb.cp/demangle.exp: gnu: Valid__7CatalogPCcRP4Tool +PASS: gdb.cp/demangle.exp: gnu: _10PageButton$__both +PASS: gdb.cp/demangle.exp: gnu: _3RNG$singleMantissa +PASS: gdb.cp/demangle.exp: gnu: _5IComp$_release +PASS: gdb.cp/demangle.exp: gnu: _$_10BitmapComp +PASS: gdb.cp/demangle.exp: gnu: _$_9__io_defs +PASS: gdb.cp/demangle.exp: gnu: _$_Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: _$_Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __10ivTelltaleiP7ivGlyph +PASS: gdb.cp/demangle.exp: gnu: __10ivViewportiP12ivInteractorUi +PASS: gdb.cp/demangle.exp: gnu: __10ostrstream +PASS: gdb.cp/demangle.exp: gnu: __10ostrstreamPcii +PASS: gdb.cp/demangle.exp: gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui +PASS: gdb.cp/demangle.exp: gnu: __11BitmapTablei +PASS: gdb.cp/demangle.exp: gnu: __12ViewportCodeP12ViewportComp +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_BorderiPCci +PASS: gdb.cp/demangle.exp: gnu: __12iv2_6_Borderii +PASS: gdb.cp/demangle.exp: gnu: __12ivBackgroundiP7ivGlyphPC7ivColor +PASS: gdb.cp/demangle.exp: gnu: __12ivBreak_Listl +PASS: gdb.cp/demangle.exp: gnu: __14TextInteractoriPCcUi +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __14iv2_6_MenuItemiPCcP12ivInteractor +PASS: gdb.cp/demangle.exp: gnu: __20DisplayList_IteratorR11DisplayList +PASS: gdb.cp/demangle.exp: gnu: __3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __3fooiN31 +PASS: gdb.cp/demangle.exp: gnu: __3fooiPCc +PASS: gdb.cp/demangle.exp: gnu: __3fooiRT0iT2iT2 +PASS: gdb.cp/demangle.exp: gnu: __6GetOptiPPcPCc +PASS: gdb.cp/demangle.exp: gnu: __6KeyMapPT0 +PASS: gdb.cp/demangle.exp: gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData +PASS: gdb.cp/demangle.exp: gnu: __7procbufPCci +PASS: gdb.cp/demangle.exp: gnu: __8ArrowCmdP6EditorUiUi +PASS: gdb.cp/demangle.exp: gnu: __9F_EllipseiiiiP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __9FrameDataP9FrameCompi +PASS: gdb.cp/demangle.exp: gnu: __9HVGraphicP9CanvasVarP7Graphic +PASS: gdb.cp/demangle.exp: gnu: __Q23foo3bar +PASS: gdb.cp/demangle.exp: gnu: __Q33foo3bar4bell +PASS: gdb.cp/demangle.exp: gnu: __aa__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ad__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __adv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aer__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __als__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __amd__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ami__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__3FixRT0 +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix16i +PASS: gdb.cp/demangle.exp: gnu: __aml__5Fix32RT0 +PASS: gdb.cp/demangle.exp: gnu: __aor__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __apl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ars__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __as__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __cl__6Normal +PASS: gdb.cp/demangle.exp: gnu: __cl__6Stringii +PASS: gdb.cp/demangle.exp: gnu: __cm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __co__3foo +PASS: gdb.cp/demangle.exp: gnu: __dl__3fooPv +PASS: gdb.cp/demangle.exp: gnu: __dv__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __er__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ge__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __gt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __le__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamPFR3ios_R3ios +PASS: gdb.cp/demangle.exp: gnu: __ls__FR7ostreamR3Fix +PASS: gdb.cp/demangle.exp: gnu: __lt__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __md__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mi__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ml__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __mm__3fooi +PASS: gdb.cp/demangle.exp: gnu: __ne__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7ComplexT0 +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC7Complexd +PASS: gdb.cp/demangle.exp: gnu: __ne__FRC9SubStringRC6String +PASS: gdb.cp/demangle.exp: gnu: __nt__3foo +PASS: gdb.cp/demangle.exp: gnu: __nw__3fooi +PASS: gdb.cp/demangle.exp: gnu: __oo__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __opPc__3foo +PASS: gdb.cp/demangle.exp: gnu: __opi__3foo +PASS: gdb.cp/demangle.exp: gnu: __or__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pl__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __pp__3fooi +PASS: gdb.cp/demangle.exp: gnu: __rf__3foo +PASS: gdb.cp/demangle.exp: gnu: __rm__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __rs__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __vc__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: _gsub__6StringRC5RegexPCci +PASS: gdb.cp/demangle.exp: gnu: _new_Fix__FUs +PASS: gdb.cp/demangle.exp: gnu: _vt.foo +PASS: gdb.cp/demangle.exp: gnu: _vt.foo.bar +PASS: gdb.cp/demangle.exp: gnu: _vt$foo +PASS: gdb.cp/demangle.exp: gnu: _vt$foo$bar +PASS: gdb.cp/demangle.exp: gnu: append__7ivGlyphPT0 +PASS: gdb.cp/demangle.exp: gnu: arg__FRC7Complex +PASS: gdb.cp/demangle.exp: gnu: clearok__FP7_win_sti +PASS: gdb.cp/demangle.exp: gnu: complexfunc2__FPFPc_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc3__FPFPFPl_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc4__FPFPFPc_s_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc5__FPFPc_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc6__FPFPi_PFl_i +PASS: gdb.cp/demangle.exp: gnu: complexfunc7__FPFPFPc_i_PFl_i +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC10BitPattern +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRC12BitSubStringi +PASS: gdb.cp/demangle.exp: gnu: contains__C9BitStringRT0 +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntRepT0P6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FPC6IntReplP6IntRep +PASS: gdb.cp/demangle.exp: gnu: div__FRC8RationalT0R8Rational +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerT0R7IntegerT2 +PASS: gdb.cp/demangle.exp: gnu: divide__FRC7IntegerlR7IntegerRl +PASS: gdb.cp/demangle.exp: gnu: enable__14DocumentViewerPCcUi +PASS: gdb.cp/demangle.exp: gnu: foo__FiN30 +PASS: gdb.cp/demangle.exp: gnu: foo__FiR3fooiT1iT1 +PASS: gdb.cp/demangle.exp: gnu: foo___3barl +PASS: gdb.cp/demangle.exp: gnu: insert__15ivClippingStacklRP8_XRegion +PASS: gdb.cp/demangle.exp: gnu: insert__16ChooserInfo_ListlR11ChooserInfo +PASS: gdb.cp/demangle.exp: gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep +PASS: gdb.cp/demangle.exp: gnu: leaveok__FP7_win_stc +PASS: gdb.cp/demangle.exp: gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle +PASS: gdb.cp/demangle.exp: gnu: matches__C9BitStringRC10BitPatterni +PASS: gdb.cp/demangle.exp: gnu: matches__C9SubStringRC5Regex +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FSc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__FUs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fc +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fd +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Ff +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fi +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fl +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fs +PASS: gdb.cp/demangle.exp: gnu: overload1arg__Fv +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fi +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: overloadargs__Fiiiiiiiiiii +PASS: gdb.cp/demangle.exp: gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit +PASS: gdb.cp/demangle.exp: gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation +PASS: gdb.cp/demangle.exp: gnu: poke__8ivRasterUlUlffff +PASS: gdb.cp/demangle.exp: gnu: polar__Fdd +PASS: gdb.cp/demangle.exp: gnu: read__10osStdInputRPCc +PASS: gdb.cp/demangle.exp: gnu: scale__13ivTransformerff +PASS: gdb.cp/demangle.exp: gnu: scanw__12CursesWindowPCce +PASS: gdb.cp/demangle.exp: gnu: scmp__FPCcT0 +PASS: gdb.cp/demangle.exp: gnu: sgetn__7filebufPci +PASS: gdb.cp/demangle.exp: gnu: shift__FP5_FrepiT0 +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSeti +PASS: gdb.cp/demangle.exp: gnu: test__C6BitSetii +PASS: gdb.cp/demangle.exp: gnu: testbit__FRC7Integerl +PASS: gdb.cp/demangle.exp: gnu: text_source__8Documentl +PASS: gdb.cp/demangle.exp: gnu: variance__6Erlangd +PASS: gdb.cp/demangle.exp: gnu: vform__8iostreamPCcPc +PASS: gdb.cp/demangle.exp: gnu: view__14DocumentViewerP8ItemViewP11TabularItem +PASS: gdb.cp/demangle.exp: gnu: xy_extents__11ivExtensionffff +PASS: gdb.cp/demangle.exp: gnu: zero__8osMemoryPvUi +PASS: gdb.cp/demangle.exp: gnu: _2T4$N +PASS: gdb.cp/demangle.exp: gnu: _Q22T42t1$N +PASS: gdb.cp/demangle.exp: gnu: get__2T1 +PASS: gdb.cp/demangle.exp: gnu: get__Q22T11a +PASS: gdb.cp/demangle.exp: gnu: get__Q32T11a1b +PASS: gdb.cp/demangle.exp: gnu: get__Q42T11a1b1c +PASS: gdb.cp/demangle.exp: gnu: get__Q52T11a1b1c1d +PASS: gdb.cp/demangle.exp: gnu: put__2T1i +PASS: gdb.cp/demangle.exp: gnu: put__Q22T11ai +PASS: gdb.cp/demangle.exp: gnu: put__Q32T11a1bi +PASS: gdb.cp/demangle.exp: gnu: put__Q42T11a1b1ci +PASS: gdb.cp/demangle.exp: gnu: put__Q52T11a1b1c1di +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__3fooPCv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPv +PASS: gdb.cp/demangle.exp: gnu: bar__C3fooPCv +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: __eq__3fooRC3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooR3foo +PASS: gdb.cp/demangle.exp: gnu: __eq__C3fooRT0 +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: elem__t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: __t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zdi +PASS: gdb.cp/demangle.exp: gnu: _$_t6vector1Zii +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11ZcUi +PASS: gdb.cp/demangle.exp: gnu: __nw__t2T11Z1tUi +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11ZcPv +PASS: gdb.cp/demangle.exp: gnu: __dl__t2T11Z1tPv +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zci +PASS: gdb.cp/demangle.exp: gnu: __t2T11Zc +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1ti +PASS: gdb.cp/demangle.exp: gnu: __t2T11Z1t +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0 +PASS: gdb.cp/demangle.exp: gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element +PASS: gdb.cp/demangle.exp: gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity +PASS: gdb.cp/demangle.exp: gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$D$set +PASS: gdb.cp/demangle.exp: gnu: _GLOBAL_$I$set +PASS: gdb.cp/demangle.exp: gnu: __as__t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCUiPT0 +PASS: gdb.cp/demangle.exp: gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi +PASS: gdb.cp/demangle.exp: gnu: __t5ListS1ZUiRCt5ListS1ZUi +PASS: gdb.cp/demangle.exp: gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix +PASS: gdb.cp/demangle.exp: gnu: __t8ListElem1Z5LabelRt4List1Z5Label +PASS: gdb.cp/demangle.exp: gnu: __t8BDDHookV1ZPcRCPc +PASS: gdb.cp/demangle.exp: gnu: _vt$t8BDDHookV1ZPc +PASS: gdb.cp/demangle.exp: gnu: __ne__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: __eq__FPvRCQ211BDDFunction4VixB +PASS: gdb.cp/demangle.exp: gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters +PASS: gdb.cp/demangle.exp: gnu: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: gnu: foo__I40 +PASS: gdb.cp/demangle.exp: gnu: foo__I_200_ +PASS: gdb.cp/demangle.exp: gnu: foo__I_200 +PASS: gdb.cp/demangle.exp: gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000 +PASS: gdb.cp/demangle.exp: gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator +PASS: gdb.cp/demangle.exp: arm: set demangle-style +PASS: gdb.cp/demangle.exp: arm: check demangling style +PASS: gdb.cp/demangle.exp: arm: __dt__21T5__pt__11_PFiPPdPv_iFv +PASS: gdb.cp/demangle.exp: arm: __ct__1cFi +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_iFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T5__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: arm: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: arm: __dt__12T5__pt__3_1xFv +PASS: gdb.cp/demangle.exp: arm: __dt__17T5__pt__8_PFcPv_iFv +PASS: gdb.cp/demangle.exp: arm: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: arm: __ct__21T5__pt__11_PFiPPdPv_iFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: arm: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: arm: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: arm: put__2T7SFi +PASS: gdb.cp/demangle.exp: arm: __dl__12T5__pt__3_1xSFPv +PASS: gdb.cp/demangle.exp: arm: h__FUc +PASS: gdb.cp/demangle.exp: arm: f__Fic +PASS: gdb.cp/demangle.exp: arm: h__FUi +PASS: gdb.cp/demangle.exp: arm: h__Fci +PASS: gdb.cp/demangle.exp: arm: h__FUl +PASS: gdb.cp/demangle.exp: arm: h__Fcl +PASS: gdb.cp/demangle.exp: arm: h__FUs +PASS: gdb.cp/demangle.exp: arm: h__Fcs +PASS: gdb.cp/demangle.exp: arm: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: arm: X__12T5__pt__3_1x +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T5__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: arm: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: arm: h__FcT1 +PASS: gdb.cp/demangle.exp: arm: f__Ficd +PASS: gdb.cp/demangle.exp: arm: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: arm: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: arm: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: arm: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: arm: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: arm: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: arm: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: arm: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: arm: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: arm: __dl__17T5__pt__8_PFcPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: printf__FPCce +PASS: gdb.cp/demangle.exp: arm: X__17T5__pt__8_PFcPv_i +PASS: gdb.cp/demangle.exp: arm: __ct__12T5__pt__3_1xFi +PASS: gdb.cp/demangle.exp: arm: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: arm: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: arm: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv +PASS: gdb.cp/demangle.exp: arm: __std__foo +PASS: gdb.cp/demangle.exp: arm: __sti__bar +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: arm: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: arm: get__2T7SFv +PASS: gdb.cp/demangle.exp: arm: X__21T5__pt__11_PFiPPdPv_i +PASS: gdb.cp/demangle.exp: arm: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: arm: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_iSFPv +PASS: gdb.cp/demangle.exp: arm: __dl__11T5__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: h__Fc +PASS: gdb.cp/demangle.exp: arm: h__Fd +PASS: gdb.cp/demangle.exp: arm: h__Ff +PASS: gdb.cp/demangle.exp: arm: h__Fi +PASS: gdb.cp/demangle.exp: arm: f__Fi +PASS: gdb.cp/demangle.exp: arm: h__Fl +PASS: gdb.cp/demangle.exp: arm: h__Fs +PASS: gdb.cp/demangle.exp: arm: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: arm: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_c +PASS: gdb.cp/demangle.exp: arm: X__11T5__pt__2_i +PASS: gdb.cp/demangle.exp: arm: g__FdCdT1 +PASS: gdb.cp/demangle.exp: arm: g__FfCfT1 +PASS: gdb.cp/demangle.exp: arm: g__FlClT1 +PASS: gdb.cp/demangle.exp: arm: g__FiCiT1 +PASS: gdb.cp/demangle.exp: arm: g__FsCsT1 +PASS: gdb.cp/demangle.exp: arm: g__FcCcT1 +PASS: gdb.cp/demangle.exp: arm: __ct__17T5__pt__8_PFcPv_iFi +PASS: gdb.cp/demangle.exp: arm: f__FicdPc +PASS: gdb.cp/demangle.exp: arm: __nw__FUi +PASS: gdb.cp/demangle.exp: arm: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: arm: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: arm: put__2T1SFi +PASS: gdb.cp/demangle.exp: arm: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: arm: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: arm: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: arm: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: arm: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: arm: get__2T1SFv +PASS: gdb.cp/demangle.exp: arm: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: arm: __dt__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __dt__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__12T1__pt__3_1tSFPv +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFi +PASS: gdb.cp/demangle.exp: arm: __ct__11T1__pt__2_cFv +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFi +PASS: gdb.cp/demangle.exp: arm: __ct__12T1__pt__3_1tFv +PASS: gdb.cp/demangle.exp: arm: __dl__11T1__pt__2_cSFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: arm: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: arm: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: elem__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_dFi +PASS: gdb.cp/demangle.exp: arm: __ct__15vector__pt__2_iFi +PASS: gdb.cp/demangle.exp: arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2 +PASS: gdb.cp/demangle.exp: arm: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: arm: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: arm: _Utf390_1__1_9223372036854775807__9223372036854775 +PASS: gdb.cp/demangle.exp: hp: set demangle-style +PASS: gdb.cp/demangle.exp: hp: check demangling style +PASS: gdb.cp/demangle.exp: hp: g__FP1cPC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUlPCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUiPCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUsPCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPUcPCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TPlPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRlRClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPiPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRiRCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPsPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRsRCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TPcPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRcRCcT2 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2c +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2i +PASS: gdb.cp/demangle.exp: hp: __nw__2T1SFUi +PASS: gdb.cp/demangle.exp: hp: __dl__2T1SFPv +PASS: gdb.cp/demangle.exp: hp: put__2T7SFi +PASS: gdb.cp/demangle.exp: hp: h__FUc +PASS: gdb.cp/demangle.exp: hp: f__Fic +PASS: gdb.cp/demangle.exp: hp: h__FUi +PASS: gdb.cp/demangle.exp: hp: h__Fci +PASS: gdb.cp/demangle.exp: hp: h__FUl +PASS: gdb.cp/demangle.exp: hp: h__Fcl +PASS: gdb.cp/demangle.exp: hp: h__FUs +PASS: gdb.cp/demangle.exp: hp: h__Fcs +PASS: gdb.cp/demangle.exp: hp: __amd__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __adv__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __amu__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ami__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __apl__FR2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUlRPCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUiRPCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUsRPCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPUcRPCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPlRPClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPiRPCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1SRPcRPCcT3 +PASS: gdb.cp/demangle.exp: hp: __gt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ge__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __lt__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __le__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __ne__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: __eq__FRC2T2T1 +PASS: gdb.cp/demangle.exp: hp: g__FcR1cRC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPdRPCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRPfRPCfT2 +PASS: gdb.cp/demangle.exp: hp: h__FcT1 +PASS: gdb.cp/demangle.exp: hp: f__Ficd +PASS: gdb.cp/demangle.exp: hp: g__F1T1SdRPsRPCsT4 +PASS: gdb.cp/demangle.exp: hp: g__F1cC1cT1 +PASS: gdb.cp/demangle.exp: hp: g__FPdPCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FPfPCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FUlCUlT1 +PASS: gdb.cp/demangle.exp: hp: g__FPlPClT1 +PASS: gdb.cp/demangle.exp: hp: g__FUiCUiT1 +PASS: gdb.cp/demangle.exp: hp: g__FPiPCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FUsCUsT1 +PASS: gdb.cp/demangle.exp: hp: g__FPsPCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FUcCUcT1 +PASS: gdb.cp/demangle.exp: hp: g__FPcPCcT1 +PASS: gdb.cp/demangle.exp: hp: g__F1TlClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TiCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TsCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1TcCcT2 +PASS: gdb.cp/demangle.exp: hp: printf__FPCce +PASS: gdb.cp/demangle.exp: hp: g__F1SRUlRCUlT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPlRPClT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUiRCUiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPiRPCiT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUsRCUsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPsRPCsT2 +PASS: gdb.cp/demangle.exp: hp: g__F1RRUcRCUcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1SRPcRPCcT2 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRlRClT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRiRCiT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRsRCsT3 +PASS: gdb.cp/demangle.exp: hp: g__F1T1RRcRCcT3 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFic_v +PASS: gdb.cp/demangle.exp: hp: get__2T7SFv +PASS: gdb.cp/demangle.exp: hp: g__FcRdRCdT2 +PASS: gdb.cp/demangle.exp: hp: g__FcRfRCfT2 +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2i +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2i +PASS: gdb.cp/demangle.exp: hp: h__Fc +PASS: gdb.cp/demangle.exp: hp: h__Fd +PASS: gdb.cp/demangle.exp: hp: h__Ff +PASS: gdb.cp/demangle.exp: hp: h__Fi +PASS: gdb.cp/demangle.exp: hp: f__Fi +PASS: gdb.cp/demangle.exp: hp: h__Fl +PASS: gdb.cp/demangle.exp: hp: h__Fs +PASS: gdb.cp/demangle.exp: hp: __md__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __dv__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __ml__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __mi__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: __pl__FC2T2RC2T2 +PASS: gdb.cp/demangle.exp: hp: g__FcRP1cRPC1cT2 +PASS: gdb.cp/demangle.exp: hp: g__FdCdT1 +PASS: gdb.cp/demangle.exp: hp: g__FfCfT1 +PASS: gdb.cp/demangle.exp: hp: g__FlClT1 +PASS: gdb.cp/demangle.exp: hp: g__FiCiT1 +PASS: gdb.cp/demangle.exp: hp: g__FsCsT1 +PASS: gdb.cp/demangle.exp: hp: g__FcCcT1 +PASS: gdb.cp/demangle.exp: hp: f__FicdPc +PASS: gdb.cp/demangle.exp: hp: __nw__FUi +PASS: gdb.cp/demangle.exp: hp: __ct__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: __dt__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: put__Q3_2T11a1bSFi +PASS: gdb.cp/demangle.exp: hp: get__Q2_2T11aSFv +PASS: gdb.cp/demangle.exp: hp: put__2T1SFi +PASS: gdb.cp/demangle.exp: hp: put__Q5_2T11a1b1c1dSFi +PASS: gdb.cp/demangle.exp: hp: get__Q4_2T11a1b1cSFv +PASS: gdb.cp/demangle.exp: hp: put__Q2_2T11aSFi +PASS: gdb.cp/demangle.exp: hp: put__Q4_2T11a1b1cSFi +PASS: gdb.cp/demangle.exp: hp: get__Q3_2T11a1bSFv +PASS: gdb.cp/demangle.exp: hp: get__2T1SFv +PASS: gdb.cp/demangle.exp: hp: get__Q5_2T11a1b1c1dSFv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPCv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPv +PASS: gdb.cp/demangle.exp: hp: bar__3fooCFPCv +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooFRC3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFR3foo +PASS: gdb.cp/demangle.exp: hp: __eq__3fooCFRC3foo +PASS: gdb.cp/demangle.exp: hp: bar__3fooFiT16FooBar +PASS: gdb.cp/demangle.exp: hp: bar__3fooFPiN51PdN37PcN211T1iN215 +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFiPPdPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__1cFi +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTi__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T2Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XT1x__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T5XTPFcPv_i__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFiPPdPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XT1x__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XT1x +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFcPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFcPv_i +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XT1x__Fi +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTPFiPPdPv_i__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTPFiPPdPv_i +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTi__SFPv +PASS: gdb.cp/demangle.exp: hp: __dl__2T5XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: X__2T5XTc +PASS: gdb.cp/demangle.exp: hp: X__2T5XTi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __dt__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XT1t__SFPv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XTc__Fv +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T1XT1t__Fv +PASS: gdb.cp/demangle.exp: hp: __dl__2T1XTc__SFPv +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTd__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__6vectorXTi__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiUP34__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXUP2701Td__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSP334__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSM__SCFPPd +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67UP4000TRs__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN67TRdTFPv_i__Fi +PASS: gdb.cp/demangle.exp: hp: X__6vectorXTiSN67TdTPvUP5TRs +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3foo__Fi +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2 +PASS: gdb.cp/demangle.exp: hp: elem__6vectorXTiSN42A3foo__Fi +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_2 +PASS: gdb.cp/demangle.exp: hp: __ct__2T5XTPFcPv_i__Fi_19 +PASS: gdb.cp/demangle.exp: hp: f__FicdPcPFci_v_34 +PASS: gdb.cp/demangle.exp: hp: spec__13Spec<%1,%1.*>XTiTPi_FPi +PASS: gdb.cp/demangle.exp: hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi +PASS: gdb.cp/demangle.exp: hp: add__XTc_FcT1 +PASS: gdb.cp/demangle.exp: hp: add__XTcSP9A5label_FcPPlT1 +PASS: gdb.cp/demangle.exp: hp: add__XTPfTFPd_f_FcT1 +PASS: gdb.cp/demangle.exp: hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv +PASS: gdb.cp/demangle.exp: hp: _Utf390_1__1_9223372036854775807__9223372036854775 +Running ./gdb.cp/derivation.exp ... +PASS: gdb.cp/derivation.exp: before run: ptype A::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A::value_type +PASS: gdb.cp/derivation.exp: before run: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D::value_type +PASS: gdb.cp/derivation.exp: before run: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype E::value_type +PASS: gdb.cp/derivation.exp: before run: whatis E::value_type +PASS: gdb.cp/derivation.exp: before run: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype F::value_type +PASS: gdb.cp/derivation.exp: before run: whatis F::value_type +PASS: gdb.cp/derivation.exp: before run: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype A2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis A2::value_type +PASS: gdb.cp/derivation.exp: before run: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype D2::value_type +PASS: gdb.cp/derivation.exp: before run: whatis D2::value_type +PASS: gdb.cp/derivation.exp: before run: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype Z::value_type +PASS: gdb.cp/derivation.exp: before run: whatis Z::value_type +PASS: gdb.cp/derivation.exp: before run: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: before run: ptype ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: whatis ZZ::value_type +PASS: gdb.cp/derivation.exp: before run: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis A2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (A2::value_type) 0 +PASS: gdb.cp/derivation.exp: at marker1: ptype D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: whatis D2::value_type +PASS: gdb.cp/derivation.exp: at marker1: p (D2::value_type) 0 +PASS: gdb.cp/derivation.exp: up from marker1 +PASS: gdb.cp/derivation.exp: print value of a_instance +PASS: gdb.cp/derivation.exp: ptype a_instance +PASS: gdb.cp/derivation.exp: print value of d_instance +PASS: gdb.cp/derivation.exp: ptype d_instance +PASS: gdb.cp/derivation.exp: print value of e_instance +PASS: gdb.cp/derivation.exp: ptype e_instance +PASS: gdb.cp/derivation.exp: print value of f_instance +PASS: gdb.cp/derivation.exp: ptype f_instance +PASS: gdb.cp/derivation.exp: ptype g_instance +PASS: gdb.cp/derivation.exp: print value of d_instance.a +PASS: gdb.cp/derivation.exp: print value of d_instance.aa +PASS: gdb.cp/derivation.exp: print value of d_instance.b +PASS: gdb.cp/derivation.exp: print value of d_instance.bb +PASS: gdb.cp/derivation.exp: print value of d_instance.c +PASS: gdb.cp/derivation.exp: print value of d_instance.cc +PASS: gdb.cp/derivation.exp: print value of d_instance.d +PASS: gdb.cp/derivation.exp: print value of d_instance.dd +PASS: gdb.cp/derivation.exp: print value of g_instance.a +PASS: gdb.cp/derivation.exp: print value of g_instance.b +PASS: gdb.cp/derivation.exp: print value of g_instance.c +PASS: gdb.cp/derivation.exp: print value of g_instance.afoo() +PASS: gdb.cp/derivation.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/derivation.exp: print value of g_instance.bfoo() +PASS: gdb.cp/derivation.exp: print value of g_instance.cfoo() +PASS: gdb.cp/derivation.exp: whatis c_instance.c +PASS: gdb.cp/derivation.exp: ptype c_instance.c +PASS: gdb.cp/derivation.exp: whatis g_instance.g +PASS: gdb.cp/derivation.exp: ptype g_instance.g +PASS: gdb.cp/derivation.exp: whatis a_instance.a +PASS: gdb.cp/derivation.exp: ptype a_instance.a +PASS: gdb.cp/derivation.exp: p (A::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis b_instance.b +PASS: gdb.cp/derivation.exp: ptype b_instance.b +PASS: gdb.cp/derivation.exp: whatis d_instance.d +PASS: gdb.cp/derivation.exp: ptype d_instance.d +PASS: gdb.cp/derivation.exp: p (D::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis e_instance.e +PASS: gdb.cp/derivation.exp: ptype e_instance.e +PASS: gdb.cp/derivation.exp: p (E::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis f_instance.f +PASS: gdb.cp/derivation.exp: ptype f_instance.f +PASS: gdb.cp/derivation.exp: p (F::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis z_instance.z +PASS: gdb.cp/derivation.exp: ptype z_instance.z +PASS: gdb.cp/derivation.exp: p (Z::value_type) 0 +PASS: gdb.cp/derivation.exp: whatis zz_instance.zz +PASS: gdb.cp/derivation.exp: ptype zz_instance.zz +PASS: gdb.cp/derivation.exp: p (ZZ::value_type) 0 +PASS: gdb.cp/derivation.exp: ptype vderived +PASS: gdb.cp/derivation.exp: print vderived +PASS: gdb.cp/derivation.exp: ptype N::value_type +PASS: gdb.cp/derivation.exp: ptype N::Derived::value_type +PASS: gdb.cp/derivation.exp: ptype value_type +Running ./gdb.cp/destrprint.exp ... +PASS: gdb.cp/destrprint.exp: continue to breakpoint: Break here +PASS: gdb.cp/destrprint.exp: go up to ~Derived +PASS: gdb.cp/destrprint.exp: set print object on +PASS: gdb.cp/destrprint.exp: print *this with print object = on +PASS: gdb.cp/destrprint.exp: set print object off +PASS: gdb.cp/destrprint.exp: print *this with print object = off +Running ./gdb.cp/dispcxx.exp ... +PASS: gdb.cp/dispcxx.exp: continue to breakpoint: here +PASS: gdb.cp/dispcxx.exp: display k +Running ./gdb.cp/exception.exp ... +PASS: gdb.cp/exception.exp: catch catch (before inferior run) +PASS: gdb.cp/exception.exp: catch throw (before inferior run) +PASS: gdb.cp/exception.exp: info breakpoints (before inferior run) +PASS: gdb.cp/exception.exp: Set temporary breakpoint at main +PASS: gdb.cp/exception.exp: Run to main +PASS: gdb.cp/exception.exp: info breakpoints (after inferior run) +PASS: gdb.cp/exception.exp: break catcher +PASS: gdb.cp/exception.exp: continue to first throw +PASS: gdb.cp/exception.exp: backtrace after first throw +PASS: gdb.cp/exception.exp: continue to first catch +PASS: gdb.cp/exception.exp: backtrace after first catch +PASS: gdb.cp/exception.exp: continue to catcher for the first time +PASS: gdb.cp/exception.exp: continue to second throw +PASS: gdb.cp/exception.exp: backtrace after second throw +PASS: gdb.cp/exception.exp: continue to second catch +PASS: gdb.cp/exception.exp: backtrace after second catch +PASS: gdb.cp/exception.exp: continue to catcher for the second time +Running ./gdb.cp/expand-psymtabs-cxx.exp ... +PASS: gdb.cp/expand-psymtabs-cxx.exp: set language c++ +PASS: gdb.cp/expand-psymtabs-cxx.exp: before expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: force expand +PASS: gdb.cp/expand-psymtabs-cxx.exp: after expand +Running ./gdb.cp/expand-sals.exp ... +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: func +PASS: gdb.cp/expand-sals.exp: up +PASS: gdb.cp/expand-sals.exp: break +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: caller +PASS: gdb.cp/expand-sals.exp: bt from A +PASS: gdb.cp/expand-sals.exp: continue to breakpoint: next caller func +Running ./gdb.cp/extern-c.exp ... +PASS: gdb.cp/extern-c.exp: setting breakpoint at c_func +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_func +PASS: gdb.cp/extern-c.exp: initialize counter +PASS: gdb.cp/extern-c.exp: rbreak c_funcs +PASS: gdb.cp/extern-c.exp: command details for multiple breakpoints +PASS: gdb.cp/extern-c.exp: set commands on multiple breakpoints +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_1 +PASS: gdb.cp/extern-c.exp: verify counter at first breakpoint +PASS: gdb.cp/extern-c.exp: continue to breakpoint: c_funcs_2 +PASS: gdb.cp/extern-c.exp: verify counter at second breakpoint +Running ./gdb.cp/formatted-ref.exp ... +PASS: gdb.cp/formatted-ref.exp: print/x s +PASS: gdb.cp/formatted-ref.exp: print/x e +PASS: gdb.cp/formatted-ref.exp: print/x i +PASS: gdb.cp/formatted-ref.exp: print/x &s +PASS: gdb.cp/formatted-ref.exp: print/x &e +PASS: gdb.cp/formatted-ref.exp: print/x &i +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&s)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&i)) +PASS: gdb.cp/formatted-ref.exp: print/x *(&(&e)) +PASS: gdb.cp/formatted-ref.exp: print s.x == 13 +Running ./gdb.cp/fpointer.exp ... +PASS: gdb.cp/fpointer.exp: p p1() +PASS: gdb.cp/fpointer.exp: p p2() +PASS: gdb.cp/fpointer.exp: p p[0]() +PASS: gdb.cp/fpointer.exp: p p[1]() +PASS: gdb.cp/fpointer.exp: p p3('a') +PASS: gdb.cp/fpointer.exp: p p4(1) +Running ./gdb.cp/gdb1355.exp ... +PASS: gdb.cp/gdb1355.exp: ptype s1 +PASS: gdb.cp/gdb1355.exp: print s1 +Running ./gdb.cp/gdb2384.exp ... +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/gdb2384.exp: print d1.meth () +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/gdb2384.exp: gdb2384 +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +PASS: gdb.cp/gdb2384.exp: print d2.meth() +PASS: gdb.cp/gdb2384.exp: continue to breakpoint: set breakpoint here (second) +PASS: gdb.cp/gdb2384.exp: gdb2384 (second) +Running ./gdb.cp/gdb2495.exp ... +PASS: gdb.cp/gdb2495.exp: p exceptions.no_throw_function() +PASS: gdb.cp/gdb2495.exp: p exceptions.throw_function_with_handler() +FAIL: gdb.cp/gdb2495.exp: Call a function that raises an exception without a handler. +FAIL: gdb.cp/gdb2495.exp: bt after returning from a popped frame +PASS: gdb.cp/gdb2495.exp: info breakpoints +PASS: gdb.cp/gdb2495.exp: set unwinn-on-terminating-exception off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on terminating exception flag +PASS: gdb.cp/gdb2495.exp: Call a function that raises an exception with unwinding off.. +PASS: gdb.cp/gdb2495.exp: set unwindonsignal on +PASS: gdb.cp/gdb2495.exp: Turn on unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +PASS: gdb.cp/gdb2495.exp: set unwindonsignal off +PASS: gdb.cp/gdb2495.exp: Turn off unwind on signal +PASS: gdb.cp/gdb2495.exp: p exceptions.raise_signal(1) +Running ./gdb.cp/hang.exp ... +PASS: gdb.cp/hang.exp: doesn't overwrite struct type +PASS: gdb.cp/hang.exp: doesn't corrupt cv_type chain +Running ./gdb.cp/infcall-dlopen.exp ... +PASS: gdb.cp/infcall-dlopen.exp: test 0 +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 0 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 1 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 2 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 2 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 3 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 3 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 4 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 4 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 5 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 5 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 6 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 6 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 7 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 7 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 8 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 8 stub 2 +PASS: gdb.cp/infcall-dlopen.exp: test 9 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 1 +PASS: gdb.cp/infcall-dlopen.exp: test 9 stub 2 +Running ./gdb.cp/inherit.exp ... +PASS: gdb.cp/inherit.exp: set width 0 +PASS: gdb.cp/inherit.exp: set language c++ +PASS: gdb.cp/inherit.exp: ptype A (FIXME) +PASS: gdb.cp/inherit.exp: ptype class A (FIXME) +PASS: gdb.cp/inherit.exp: ptype g_A (FIXME) +PASS: gdb.cp/inherit.exp: ptype B +PASS: gdb.cp/inherit.exp: ptype class B +PASS: gdb.cp/inherit.exp: ptype g_B +PASS: gdb.cp/inherit.exp: ptype C +PASS: gdb.cp/inherit.exp: ptype class C +PASS: gdb.cp/inherit.exp: ptype g_C +PASS: gdb.cp/inherit.exp: ptype tagless struct +PASS: gdb.cp/inherit.exp: ptype variable of type tagless struct +PASS: gdb.cp/inherit.exp: ptype D +PASS: gdb.cp/inherit.exp: ptype class D +PASS: gdb.cp/inherit.exp: ptype g_D +PASS: gdb.cp/inherit.exp: ptype E +PASS: gdb.cp/inherit.exp: ptype class E +PASS: gdb.cp/inherit.exp: ptype g_E +PASS: gdb.cp/inherit.exp: ptype vA +PASS: gdb.cp/inherit.exp: ptype class vA +PASS: gdb.cp/inherit.exp: ptype g_vA +PASS: gdb.cp/inherit.exp: ptype vB +PASS: gdb.cp/inherit.exp: ptype class vB +PASS: gdb.cp/inherit.exp: ptype g_vB +PASS: gdb.cp/inherit.exp: ptype vC +PASS: gdb.cp/inherit.exp: ptype class vC +PASS: gdb.cp/inherit.exp: ptype g_vC +PASS: gdb.cp/inherit.exp: ptype vD +PASS: gdb.cp/inherit.exp: ptype class vD +PASS: gdb.cp/inherit.exp: ptype g_vD +PASS: gdb.cp/inherit.exp: ptype vE +PASS: gdb.cp/inherit.exp: ptype class vE +PASS: gdb.cp/inherit.exp: ptype g_vE +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_A.a +PASS: gdb.cp/inherit.exp: print g_A.x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_B.a +PASS: gdb.cp/inherit.exp: print g_B.b +PASS: gdb.cp/inherit.exp: print g_B.x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_C.a +PASS: gdb.cp/inherit.exp: print g_C.c +PASS: gdb.cp/inherit.exp: print g_C.x +PASS: gdb.cp/inherit.exp: print g_A +PASS: gdb.cp/inherit.exp: print g_B +PASS: gdb.cp/inherit.exp: print g_C +PASS: gdb.cp/inherit.exp: print g_A.A::a +PASS: gdb.cp/inherit.exp: print g_A.A::x +PASS: gdb.cp/inherit.exp: print g_B.A::a +PASS: gdb.cp/inherit.exp: print g_B.A::x +PASS: gdb.cp/inherit.exp: print g_B.B::b +PASS: gdb.cp/inherit.exp: print g_B.B::x +PASS: gdb.cp/inherit.exp: print g_C.A::a +PASS: gdb.cp/inherit.exp: print g_C.A::x +PASS: gdb.cp/inherit.exp: print g_C.C::c +PASS: gdb.cp/inherit.exp: print g_C.C::x +PASS: gdb.cp/inherit.exp: print g_D.A::a +PASS: gdb.cp/inherit.exp: print g_D.C::a +PASS: gdb.cp/inherit.exp: print g_D.B::a +PASS: gdb.cp/inherit.exp: print g_D.A::x +PASS: gdb.cp/inherit.exp: print g_D.B::b +PASS: gdb.cp/inherit.exp: print g_D.B::x +PASS: gdb.cp/inherit.exp: print g_D.C::c +PASS: gdb.cp/inherit.exp: print g_D.C::x +PASS: gdb.cp/inherit.exp: print g_D.D::d +PASS: gdb.cp/inherit.exp: print g_D.D::x +PASS: gdb.cp/inherit.exp: print g_E.A::a +PASS: gdb.cp/inherit.exp: print g_E.A::x +PASS: gdb.cp/inherit.exp: print g_E.B::b +PASS: gdb.cp/inherit.exp: print g_E.B::x +PASS: gdb.cp/inherit.exp: print g_E.C::c +PASS: gdb.cp/inherit.exp: print g_E.C::x +PASS: gdb.cp/inherit.exp: print g_E.D::d +PASS: gdb.cp/inherit.exp: print g_E.D::x +PASS: gdb.cp/inherit.exp: print g_E.E::e +PASS: gdb.cp/inherit.exp: print g_E.E::x +PASS: gdb.cp/inherit.exp: ptype g_D.b +PASS: gdb.cp/inherit.exp: ptype g_D.c +PASS: gdb.cp/inherit.exp: ptype g_D.d +PASS: gdb.cp/inherit.exp: ptype g_A.A::a +PASS: gdb.cp/inherit.exp: ptype g_A.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.A::a +PASS: gdb.cp/inherit.exp: ptype g_B.A::x +PASS: gdb.cp/inherit.exp: ptype g_B.B::b +PASS: gdb.cp/inherit.exp: ptype g_B.B::x +PASS: gdb.cp/inherit.exp: ptype g_C.A::a +PASS: gdb.cp/inherit.exp: ptype g_C.A::x +PASS: gdb.cp/inherit.exp: ptype g_C.C::c +PASS: gdb.cp/inherit.exp: ptype g_C.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.A::a +PASS: gdb.cp/inherit.exp: ptype g_D.A::x +PASS: gdb.cp/inherit.exp: ptype g_D.B::b +PASS: gdb.cp/inherit.exp: ptype g_D.B::x +PASS: gdb.cp/inherit.exp: ptype g_D.C::c +PASS: gdb.cp/inherit.exp: ptype g_D.C::x +PASS: gdb.cp/inherit.exp: ptype g_D.D::d +PASS: gdb.cp/inherit.exp: ptype g_D.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.A::a +PASS: gdb.cp/inherit.exp: ptype g_E.A::x +PASS: gdb.cp/inherit.exp: ptype g_E.B::b +PASS: gdb.cp/inherit.exp: ptype g_E.B::x +PASS: gdb.cp/inherit.exp: ptype g_E.C::c +PASS: gdb.cp/inherit.exp: ptype g_E.C::x +PASS: gdb.cp/inherit.exp: ptype g_E.D::d +PASS: gdb.cp/inherit.exp: ptype g_E.D::x +PASS: gdb.cp/inherit.exp: ptype g_E.E::e +PASS: gdb.cp/inherit.exp: ptype g_E.E::x +PASS: gdb.cp/inherit.exp: print g_D +PASS: gdb.cp/inherit.exp: print g_E +PASS: gdb.cp/inherit.exp: print anonymous union member +PASS: gdb.cp/inherit.exp: print variable of type anonymous union +PASS: gdb.cp/inherit.exp: print type of anonymous union +PASS: gdb.cp/inherit.exp: print g_vA.vA::va +PASS: gdb.cp/inherit.exp: print g_vA.vA::vx +PASS: gdb.cp/inherit.exp: print g_vA.va +PASS: gdb.cp/inherit.exp: print g_vA.vx +PASS: gdb.cp/inherit.exp: print g_vB.vA::va +PASS: gdb.cp/inherit.exp: print g_vB.vA::vx +PASS: gdb.cp/inherit.exp: print g_vB.vB::vb +PASS: gdb.cp/inherit.exp: print g_vB.vB::vx +PASS: gdb.cp/inherit.exp: print g_vB.va +PASS: gdb.cp/inherit.exp: print g_vB.vb +PASS: gdb.cp/inherit.exp: print g_vB.vx +PASS: gdb.cp/inherit.exp: print g_vC.vA::va +PASS: gdb.cp/inherit.exp: print g_vC.vA::vx +PASS: gdb.cp/inherit.exp: print g_vC.vC::vc +PASS: gdb.cp/inherit.exp: print g_vC.vC::vx +PASS: gdb.cp/inherit.exp: print g_vC.va +PASS: gdb.cp/inherit.exp: print g_vC.vc +PASS: gdb.cp/inherit.exp: print g_vC.vx +PASS: gdb.cp/inherit.exp: print g_vA +PASS: gdb.cp/inherit.exp: print g_vB +PASS: gdb.cp/inherit.exp: print g_vC +PASS: gdb.cp/inherit.exp: print g_vD.vA::va +PASS: gdb.cp/inherit.exp: print g_vD.vA::vx +PASS: gdb.cp/inherit.exp: print g_vD.vB::vb +PASS: gdb.cp/inherit.exp: print g_vD.vB::vx +PASS: gdb.cp/inherit.exp: print g_vD.vC::vc +PASS: gdb.cp/inherit.exp: print g_vD.vC::vx +PASS: gdb.cp/inherit.exp: print g_vD.vD::vd +PASS: gdb.cp/inherit.exp: print g_vD.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vA::va +PASS: gdb.cp/inherit.exp: print g_vE.vA::vx +PASS: gdb.cp/inherit.exp: print g_vE.vB::vb +PASS: gdb.cp/inherit.exp: print g_vE.vB::vx +PASS: gdb.cp/inherit.exp: print g_vE.vC::vc +PASS: gdb.cp/inherit.exp: print g_vE.vC::vx +PASS: gdb.cp/inherit.exp: print g_vE.vD::vd +PASS: gdb.cp/inherit.exp: print g_vE.vD::vx +PASS: gdb.cp/inherit.exp: print g_vE.vE::ve +PASS: gdb.cp/inherit.exp: print g_vE.vE::vx +PASS: gdb.cp/inherit.exp: print g_vD (FIXME v3 vtbl ptr) +PASS: gdb.cp/inherit.exp: print g_vE (FIXME v3 vtbl ptr) +Running ./gdb.cp/koenig.exp ... +PASS: gdb.cp/koenig.exp: p first(c) +PASS: gdb.cp/koenig.exp: p second(0,0,c,0,0) +PASS: gdb.cp/koenig.exp: p entry (c) +PASS: gdb.cp/koenig.exp: p first(0,c) +PASS: gdb.cp/koenig.exp: p first(b.c) +PASS: gdb.cp/koenig.exp: p foo(eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo) +PASS: gdb.cp/koenig.exp: p foo(eo, eo, 1) +PASS: gdb.cp/koenig.exp: p foo(fo, eo) +PASS: gdb.cp/koenig.exp: p foo(1 ,fo, eo) +PASS: gdb.cp/koenig.exp: p foo(go, fo, eo) +PASS: gdb.cp/koenig.exp: p fake(eo) +PASS: gdb.cp/koenig.exp: p foo (fake) +PASS: gdb.cp/koenig.exp: p foo(io) +PASS: gdb.cp/koenig.exp: p foo(ix) +PASS: gdb.cp/koenig.exp: p foo(ju) +PASS: gdb.cp/koenig.exp: p foo(js) +PASS: gdb.cp/koenig.exp: p foo(je) +XFAIL: gdb.cp/koenig.exp: p foo(jab) +PASS: gdb.cp/koenig.exp: p foo(jap) +PASS: gdb.cp/koenig.exp: p foo(japp) +PASS: gdb.cp/koenig.exp: p foo(jca) +PASS: gdb.cp/koenig.exp: p foo(ko,1) +PASS: gdb.cp/koenig.exp: p foo(ko,1.0f) +XFAIL: gdb.cp/koenig.exp: p bar(ko,1) +PASS: gdb.cp/koenig.exp: p foo(labo) +PASS: gdb.cp/koenig.exp: p ma.foo('a') +PASS: gdb.cp/koenig.exp: p foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::FAKE::foo(ma,'a') +PASS: gdb.cp/koenig.exp: p M::N::fake(ma,'a') +PASS: gdb.cp/koenig.exp: p M::bar('a') +PASS: gdb.cp/koenig.exp: p M::N::bar('a') +PASS: gdb.cp/koenig.exp: p foo(ttoa, 'a') +PASS: gdb.cp/koenig.exp: p foo (p_union) +PASS: gdb.cp/koenig.exp: p q == 5 +PASS: gdb.cp/koenig.exp: p q == 5.0f +PASS: gdb.cp/koenig.exp: p q != 5 +PASS: gdb.cp/koenig.exp: p q != 5.0f +PASS: gdb.cp/koenig.exp: p q + 5.0f +PASS: gdb.cp/koenig.exp: p q + 5 +PASS: gdb.cp/koenig.exp: p ++q +PASS: gdb.cp/koenig.exp: p r.rfoo() +PASS: gdb.cp/koenig.exp: continue to breakpoint: marker1 +PASS: gdb.cp/koenig.exp: p rfoo() +PASS: gdb.cp/koenig.exp: p this->rfoo() +Running ./gdb.cp/local.exp ... +PASS: gdb.cp/local.exp: up from marker1 +PASS: gdb.cp/local.exp: ptype l +PASS: gdb.cp/local.exp: ptype Local +PASS: gdb.cp/local.exp: break marker2 +PASS: gdb.cp/local.exp: continuing to marker2 +PASS: gdb.cp/local.exp: up from marker2 +PASS: gdb.cp/local.exp: Local out of scope +PASS: gdb.cp/local.exp: ptype InnerLocal (pattern 1) +PASS: gdb.cp/local.exp: ptype NestedInnerLocal +KFAIL: gdb.cp/local.exp: ptype InnerLocal::NestedInnerLocal (PRMS: gdb/482) +Running ./gdb.cp/maint.exp ... +PASS: gdb.cp/maint.exp: help maintenance cplus +PASS: gdb.cp/maint.exp: help maint cp +PASS: gdb.cp/maint.exp: maint cp +PASS: gdb.cp/maint.exp: help maint cp first_component +PASS: gdb.cp/maint.exp: help maint cp namespace +PASS: gdb.cp/maint.exp: set complaints 1000 +PASS: gdb.cp/maint.exp: maint cp first_component foo +PASS: gdb.cp/maint.exp: maint cp first_component operator<< +PASS: gdb.cp/maint.exp: maint cp first_component operator>> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator() +PASS: gdb.cp/maint.exp: maint cp first_component operator> +PASS: gdb.cp/maint.exp: maint cp first_component operator< +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component operator -> +PASS: gdb.cp/maint.exp: maint cp first_component foo() +PASS: gdb.cp/maint.exp: maint cp first_component foo(int) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component foo(X::Y, A::B) +PASS: gdb.cp/maint.exp: maint cp first_component foo(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >) +PASS: gdb.cp/maint.exp: maint cp first_component operator>(X::Y) +PASS: gdb.cp/maint.exp: maint cp first_component int operator<< <char>() +PASS: gdb.cp/maint.exp: maint cp first_component T<Cooperator> +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&(operator<<(C, C))>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<&operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component int foo<operator<<(C, C)>() +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo::bar::baz +PASS: gdb.cp/maint.exp: maint cp first_component C<A>::bar +PASS: gdb.cp/maint.exp: maint cp first_component C<std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > >::bar +PASS: gdb.cp/maint.exp: maint cp first_component foo< +PASS: gdb.cp/maint.exp: maint cp first_component foo( +PASS: gdb.cp/maint.exp: maint cp first_component bool operator<<char> +PASS: gdb.cp/maint.exp: maint cp namespace +Running ./gdb.cp/mb-ctor.exp ... +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at ctor +PASS: gdb.cp/mb-ctor.exp: set-breakpoint at dtor +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v1 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 1 v2 +PASS: gdb.cp/mb-ctor.exp: continue to breakpoint: set breakpoint here +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v1 +PASS: gdb.cp/mb-ctor.exp: run to breakpoint 3 v2 +PASS: gdb.cp/mb-ctor.exp: run to exit +Running ./gdb.cp/mb-inline.exp ... +PASS: gdb.cp/mb-inline.exp: set breakpoint +PASS: gdb.cp/mb-inline.exp: info break +PASS: gdb.cp/mb-inline.exp: run to breakpoint +PASS: gdb.cp/mb-inline.exp: run to breakpoint 2 +PASS: gdb.cp/mb-inline.exp: disabling location: disable +PASS: gdb.cp/mb-inline.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-inline.exp: disabled breakpoint 1.2 +PASS: gdb.cp/mb-inline.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 afn +PASS: gdb.cp/mb-inline.exp: run to multi_line_foo breakpoint 4 bfn +Running ./gdb.cp/mb-templates.exp ... +PASS: gdb.cp/mb-templates.exp: initial condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: initial condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: kill +PASS: gdb.cp/mb-templates.exp: separate condition: set breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: set condition +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint +PASS: gdb.cp/mb-templates.exp: separate condition: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: disabling location: disable +PASS: gdb.cp/mb-templates.exp: disabling location: run to breakpoint +PASS: gdb.cp/mb-templates.exp: disabling location: enable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: disable +PASS: gdb.cp/mb-templates.exp: disable breakpoint: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: set breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint +PASS: gdb.cp/mb-templates.exp: instantiation: run to breakpoint 2 +PASS: gdb.cp/mb-templates.exp: set multi_line_foo breakpoint +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <int> +PASS: gdb.cp/mb-templates.exp: run to multi_line_foo breakpoint 2 <double> +Running ./gdb.cp/m-data.exp ... +PASS: gdb.cp/m-data.exp: continue to breakpoint: end of first constructors +PASS: gdb.cp/m-data.exp: simple object, const bool +PASS: gdb.cp/m-data.exp: simple object, const int +PASS: gdb.cp/m-data.exp: simple object, long +PASS: gdb.cp/m-data.exp: simple object, enum +PASS: gdb.cp/m-data.exp: derived template object, base const bool +PASS: gdb.cp/m-data.exp: derived template object, base const int +PASS: gdb.cp/m-data.exp: derived template object, base long +PASS: gdb.cp/m-data.exp: derived template object, base enum +PASS: gdb.cp/m-data.exp: derived template object, derived enum +PASS: gdb.cp/m-data.exp: template object, const bool +PASS: gdb.cp/m-data.exp: template object, const int +PASS: gdb.cp/m-data.exp: template object, long +PASS: gdb.cp/m-data.exp: template object, base enum +PASS: gdb.cp/m-data.exp: template object, derived enum +PASS: gdb.cp/m-data.exp: continue to breakpoint: continue to shadow breakpoint +PASS: gdb.cp/m-data.exp: shadowing member +PASS: gdb.cp/m-data.exp: shadowed global variable +Running ./gdb.cp/member-name.exp ... +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to first breakpoint +PASS: gdb.cp/member-name.exp: print C::x from first breakpoint +PASS: gdb.cp/member-name.exp: print B::b from first breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from first breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to second breakpoint +PASS: gdb.cp/member-name.exp: print C::x from second breakpoint +PASS: gdb.cp/member-name.exp: print B::b from second breakpoint +PASS: gdb.cp/member-name.exp: print inner::z from second breakpoint +PASS: gdb.cp/member-name.exp: continue to breakpoint: continue to third breakpoint +PASS: gdb.cp/member-name.exp: print Templ::y from third breakpoint +Running ./gdb.cp/member-ptr.exp ... +PASS: gdb.cp/member-ptr.exp: continue to breakpoint: continue to pmi = NULL +PASS: gdb.cp/member-ptr.exp: ptype pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (A::j) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::jj +PASS: gdb.cp/member-ptr.exp: print pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::jj) +PASS: gdb.cp/member-ptr.exp: set var pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (again) +PASS: gdb.cp/member-ptr.exp: print a.*pmi = 33 +PASS: gdb.cp/member-ptr.exp: print a.*pmi (A::j) (33) +PASS: gdb.cp/member-ptr.exp: print a (j = 33) +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi = 44 +PASS: gdb.cp/member-ptr.exp: print a_p->*pmi (44) +PASS: gdb.cp/member-ptr.exp: print a (j = 44) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmi +PASS: gdb.cp/member-ptr.exp: print *pmi +PASS: gdb.cp/member-ptr.exp: ptype *pmi +PASS: gdb.cp/member-ptr.exp: print (int) pmi +PASS: gdb.cp/member-ptr.exp: print ((int) pmi) == ((char *) &a.j - (char *) &a) +PASS: gdb.cp/member-ptr.exp: ptype diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: ptype diamond.*diamond_pfunc_ptr +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pfunc_ptr (20) +PASS: gdb.cp/member-ptr.exp: print (diamond.*diamond_pfunc_ptr) (20) +PASS: gdb.cp/member-ptr.exp: print diamond.func_ptr (20) +PASS: gdb.cp/member-ptr.exp: ptype pmf +PASS: gdb.cp/member-ptr.exp: print pmf +PASS: gdb.cp/member-ptr.exp: ptype pmf_p +PASS: gdb.cp/member-ptr.exp: gdb/NNNN +PASS: gdb.cp/member-ptr.exp: print a.*pmf +PASS: gdb.cp/member-ptr.exp: print a_p->*pmf +PASS: gdb.cp/member-ptr.exp: set var pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print *pmf +PASS: gdb.cp/member-ptr.exp: ptype *pmf +PASS: gdb.cp/member-ptr.exp: print (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: ptype a.*pmf +PASS: gdb.cp/member-ptr.exp: ptype (a.*pmf)(3) +PASS: gdb.cp/member-ptr.exp: print diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*diamond_pmi +PASS: gdb.cp/member-ptr.exp: print diamond.*left_pmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_pmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_pmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_pmf) () +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*right_vpmf +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*left_base_vpmf) () +PASS: gdb.cp/member-ptr.exp: print (diamond.*right_vpmf) () +PASS: gdb.cp/member-ptr.exp: print left_vpmf +PASS: gdb.cp/member-ptr.exp: print right_vpmf +PASS: gdb.cp/member-ptr.exp: print base_vpmf +PASS: gdb.cp/member-ptr.exp: print diamond.*left_vpmf () +PASS: gdb.cp/member-ptr.exp: print null_pmi +PASS: gdb.cp/member-ptr.exp: print null_pmi = &A::j +PASS: gdb.cp/member-ptr.exp: print null_pmi = 0 +PASS: gdb.cp/member-ptr.exp: print null_pmf +PASS: gdb.cp/member-ptr.exp: print null_pmf = &A::foo +PASS: gdb.cp/member-ptr.exp: print null_pmf = 0 +Running ./gdb.cp/method2.exp ... +PASS: gdb.cp/method2.exp: set multiple-symbols ask +PASS: gdb.cp/method2.exp: setting language c +PASS: gdb.cp/method2.exp: breaking in method (c) +PASS: gdb.cp/method2.exp: setting language c++ +PASS: gdb.cp/method2.exp: breaking in method (c++) +PASS: gdb.cp/method2.exp: continue until exit at continue to end +Running ./gdb.cp/method.exp ... +PASS: gdb.cp/method.exp: break A::foo +PASS: gdb.cp/method.exp: continue to A::foo +PASS: gdb.cp/method.exp: print x in A::foo +PASS: gdb.cp/method.exp: print this in A::foo +PASS: gdb.cp/method.exp: break A::bar +PASS: gdb.cp/method.exp: continue to A::bar +PASS: gdb.cp/method.exp: print x in A::bar +PASS: gdb.cp/method.exp: print this in A::bar +PASS: gdb.cp/method.exp: break 21 +PASS: gdb.cp/method.exp: continue to 21 +PASS: gdb.cp/method.exp: print data_ in funk::getFunky +PASS: gdb.cp/method.exp: print this in funk::getFunky +PASS: gdb.cp/method.exp: print res in funk::getFunky +PASS: gdb.cp/method.exp: ptype A +PASS: gdb.cp/method.exp: finish program +Running ./gdb.cp/meth-typedefs.exp ... +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_other_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_other_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(my_type_2, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(my_type_2, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, my_type)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(int, const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(int, const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(aenum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(aenum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, astruct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, astruct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, aunion const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, aunion const***)' +PASS: gdb.cp/meth-typedefs.exp: list test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: list 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: break test(anon_enum, anon_struct const&, anon_union const***) +PASS: gdb.cp/meth-typedefs.exp: break 'test(anon_enum, anon_struct const&, anon_union const***)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr1*) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr1*)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (**) (const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (**) (const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(fptr3) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(fptr3)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_other_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), my_type))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(fptr2, const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(fptr2, const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_other_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), my_type_2), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(fptr1, int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_other_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (my_type), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*)) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(void (*)(void (*)(void (*) (const char* const*), int), const char* const*))' +PASS: gdb.cp/meth-typedefs.exp: list test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_other_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_other_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_other_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_other_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(my_type) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(my_type)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(my_type, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(my_type, int)' +PASS: gdb.cp/meth-typedefs.exp: list B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: break B::test(const char* const*) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test(const char* const*)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_other_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, my_type_2)' +PASS: gdb.cp/meth-typedefs.exp: list B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: list 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: break B::test<my_other_type, my_other_type_2>(const char* const*, int) +PASS: gdb.cp/meth-typedefs.exp: break 'B::test<my_other_type, my_other_type_2>(const char* const*, int)' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::foo(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::foo(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(CORE_ADDR (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(CORE_ADDR (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: list 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: break A::FOO::test(unsigned long (*) [10]) +PASS: gdb.cp/meth-typedefs.exp: break 'A::FOO::test(unsigned long (*) [10])' +PASS: gdb.cp/meth-typedefs.exp: list test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: break test(_BAR_&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(_BAR_&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::BAR&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::BAR&)' +PASS: gdb.cp/meth-typedefs.exp: list test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: list 'test(a::b::c::d::bar&)' +PASS: gdb.cp/meth-typedefs.exp: break test(a::b::c::d::bar&) +PASS: gdb.cp/meth-typedefs.exp: break 'test(a::b::c::d::bar&)' +Running ./gdb.cp/minsym-fallback.exp ... +PASS: gdb.cp/minsym-fallback.exp: set breakpoint pending off +PASS: gdb.cp/minsym-fallback.exp: break C::f() +PASS: gdb.cp/minsym-fallback.exp: break C::operator()() +Running ./gdb.cp/misc.exp ... +PASS: gdb.cp/misc.exp: deduced language is C++, before full symbols +PASS: gdb.cp/misc.exp: deduced language is C++, after full symbols +PASS: gdb.cp/misc.exp: print s.a for foo struct (known gcc 2.7.2 and earlier bug) +PASS: gdb.cp/misc.exp: print as bool (setup) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 1) +PASS: gdb.cp/misc.exp: print as bool (print 1 == 2) +PASS: gdb.cp/misc.exp: print a bool var +PASS: gdb.cp/misc.exp: set a bool var (setup) +PASS: gdb.cp/misc.exp: set a bool var (print v_bool) +PASS: gdb.cp/misc.exp: print a bool array +PASS: gdb.cp/misc.exp: set a bool array elem (setup) +PASS: gdb.cp/misc.exp: set a bool array elem (print v_bool_array) +PASS: gdb.cp/misc.exp: print true +PASS: gdb.cp/misc.exp: print false +PASS: gdb.cp/misc.exp: 1 + true +PASS: gdb.cp/misc.exp: 3 + false +PASS: gdb.cp/misc.exp: 1 < 2 < 3 +PASS: gdb.cp/misc.exp: 2 < 1 > 4 +PASS: gdb.cp/misc.exp: (bool)43 +PASS: gdb.cp/misc.exp: (bool)0 +PASS: gdb.cp/misc.exp: (bool)17.93 +PASS: gdb.cp/misc.exp: (bool)0.0 +PASS: gdb.cp/misc.exp: (int)true +PASS: gdb.cp/misc.exp: (int)false +Running ./gdb.cp/m-static.exp ... +PASS: gdb.cp/m-static.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/m-static.exp: simple object, static const int, accessing via 'class::method::variable +PASS: gdb.cp/m-static.exp: simple object, static const bool +PASS: gdb.cp/m-static.exp: simple object, static const int +PASS: gdb.cp/m-static.exp: simple object, static long +PASS: gdb.cp/m-static.exp: simple object, static enum +FAIL: gdb.cp/m-static.exp: simple object instance, print quoted destructor +FAIL: gdb.cp/m-static.exp: simple object class, ptype quoted destructor +PASS: gdb.cp/m-static.exp: derived template object, base static const bool +PASS: gdb.cp/m-static.exp: derived template object, base static const int +PASS: gdb.cp/m-static.exp: derived template object, base static long +PASS: gdb.cp/m-static.exp: derived template object, base static enum +PASS: gdb.cp/m-static.exp: derived template object, static enum +PASS: gdb.cp/m-static.exp: template object, static const bool +PASS: gdb.cp/m-static.exp: template object, static const int +PASS: gdb.cp/m-static.exp: template object, static long +PASS: gdb.cp/m-static.exp: template object, static enum +PASS: gdb.cp/m-static.exp: template object, static derived enum +PASS: gdb.cp/m-static.exp: static const int initialized elsewhere +PASS: gdb.cp/m-static.exp: static const int initialized nowhere +PASS: gdb.cp/m-static.exp: static const int initialized in class definition +PASS: gdb.cp/m-static.exp: static const float initialized in class definition +PASS: gdb.cp/m-static.exp: info variable everywhere +PASS: gdb.cp/m-static.exp: step +PASS: gdb.cp/m-static.exp: print svar +Running ./gdb.cp/namespace-enum.exp ... +PASS: gdb.cp/namespace-enum.exp: print foo::B::B_B +PASS: gdb.cp/namespace-enum.exp: print foo::B_B +PASS: gdb.cp/namespace-enum.exp: print A_A +Running ./gdb.cp/namespace.exp ... +PASS: gdb.cp/namespace.exp: show lang +PASS: gdb.cp/namespace.exp: up from marker1 +PASS: gdb.cp/namespace.exp: print 'AAA::c' +PASS: gdb.cp/namespace.exp: print AAA::c +PASS: gdb.cp/namespace.exp: print ina +PASS: gdb.cp/namespace.exp: ptype ina +PASS: gdb.cp/namespace.exp: info func xyzq +PASS: gdb.cp/namespace.exp: print 'AAA::xyzq'('x') +PASS: gdb.cp/namespace.exp: print AAA::xyzq('x') +PASS: gdb.cp/namespace.exp: break AAA::xyzq +PASS: gdb.cp/namespace.exp: break ::ensureOtherRefs +PASS: gdb.cp/namespace.exp: print 'BBB::CCC::xyzq'('x') +PASS: gdb.cp/namespace.exp: print BBB::CCC::xyzq('x') +PASS: gdb.cp/namespace.exp: break BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: break ::BBB::CCC::xyzq +PASS: gdb.cp/namespace.exp: print 'BBB::Class::xyzq' +PASS: gdb.cp/namespace.exp: print BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: break BBB::Class::xyzq +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileType +PASS: gdb.cp/namespace.exp: whatis C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print C::cOtherFileVar +PASS: gdb.cp/namespace.exp: print ::C::cOtherFileVar +PASS: gdb.cp/namespace.exp: whatis C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: whatis ::C::OtherFileClass::cOtherFileClassType +PASS: gdb.cp/namespace.exp: print C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print ::C::OtherFileClass::cOtherFileClassVar +PASS: gdb.cp/namespace.exp: print c +PASS: gdb.cp/namespace.exp: print cc +PASS: gdb.cp/namespace.exp: print 'C::cc' +PASS: gdb.cp/namespace.exp: print C::cc +PASS: gdb.cp/namespace.exp: print cd +PASS: gdb.cp/namespace.exp: print C::D::cd +PASS: gdb.cp/namespace.exp: print 'E::cde' +PASS: gdb.cp/namespace.exp: print E::cde +PASS: gdb.cp/namespace.exp: print shadow +PASS: gdb.cp/namespace.exp: print E::ce +PASS: gdb.cp/namespace.exp: ptype C +PASS: gdb.cp/namespace.exp: ptype E +PASS: gdb.cp/namespace.exp: ptype CClass +PASS: gdb.cp/namespace.exp: ptype CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass +PASS: gdb.cp/namespace.exp: ptype ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype ::C::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::CClass +PASS: gdb.cp/namespace.exp: ptype C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: ptype C::NestedClass +PASS: gdb.cp/namespace.exp: print cOtherFile +PASS: gdb.cp/namespace.exp: ptype OtherFileClass +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype C::OtherFileClass +PASS: gdb.cp/namespace.exp: ptype OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: ptype ::C::OtherFileClass typedefs +PASS: gdb.cp/namespace.exp: print cX +PASS: gdb.cp/namespace.exp: print 'F::cXf' +PASS: gdb.cp/namespace.exp: print F::cXf +PASS: gdb.cp/namespace.exp: print F::cXfX +PASS: gdb.cp/namespace.exp: print X +PASS: gdb.cp/namespace.exp: print 'G::Xg' +PASS: gdb.cp/namespace.exp: print G::Xg +PASS: gdb.cp/namespace.exp: print G::XgX +PASS: gdb.cp/namespace.exp: print cXOtherFile +PASS: gdb.cp/namespace.exp: print XOtherFile +PASS: gdb.cp/namespace.exp: print AAA::ALPHA +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass +PASS: gdb.cp/namespace.exp: whatis ::C::CClass::NestedClass * +Running ./gdb.cp/namespace-nested-import.exp ... +PASS: gdb.cp/namespace-nested-import.exp: print C::x +Running ./gdb.cp/nextoverthrow.exp ... +UNSUPPORTED: gdb.cp/nextoverthrow.exp: nextoverthrow.exp could not find _Unwind_DebugHook +Running ./gdb.cp/no-dmgl-verbose.exp ... +PASS: gdb.cp/no-dmgl-verbose.exp: set breakpoint pending off +PASS: gdb.cp/no-dmgl-verbose.exp: DMGL_VERBOSE-demangled f(std::string) is not defined +Running ./gdb.cp/noparam.exp ... +PASS: gdb.cp/noparam.exp: p C::m (int) +Running ./gdb.cp/nsdecl.exp ... +PASS: gdb.cp/nsdecl.exp: print fakex +Running ./gdb.cp/nsimport.exp ... +PASS: gdb.cp/nsimport.exp: print x +PASS: gdb.cp/nsimport.exp: print xx +PASS: gdb.cp/nsimport.exp: print xxx +Running ./gdb.cp/nsnested.exp ... +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::first +PASS: gdb.cp/nsnested.exp: print ab +PASS: gdb.cp/nsnested.exp: print C::D::ab +PASS: gdb.cp/nsnested.exp: continue to breakpoint: C::D::second +PASS: gdb.cp/nsnested.exp: print ab +Running ./gdb.cp/nsnoimports.exp ... +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::first +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print C::abc +PASS: gdb.cp/nsnoimports.exp: print abc +PASS: gdb.cp/nsnoimports.exp: continue to breakpoint: A::B::C::second +PASS: gdb.cp/nsnoimports.exp: print A::_a +PASS: gdb.cp/nsnoimports.exp: print A::B::ab +PASS: gdb.cp/nsnoimports.exp: print A::B::C::abc +PASS: gdb.cp/nsnoimports.exp: print _a +PASS: gdb.cp/nsnoimports.exp: print ab +PASS: gdb.cp/nsnoimports.exp: print abc +Running ./gdb.cp/nsrecurs.exp ... +PASS: gdb.cp/nsrecurs.exp: print ax +PASS: gdb.cp/nsrecurs.exp: print dx +PASS: gdb.cp/nsrecurs.exp: print xx +KFAIL: gdb.cp/nsrecurs.exp: ptype G::GF (PRMS: gdb/10541) +KFAIL: gdb.cp/nsrecurs.exp: print G::GF::FE::ex (PRMS: gdb/10541) +Running ./gdb.cp/nsstress.exp ... +PASS: gdb.cp/nsstress.exp: print y +Running ./gdb.cp/nsusing.exp ... +PASS: gdb.cp/nsusing.exp: print _a +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker3 +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker1 stop +PASS: gdb.cp/nsusing.exp: print _a in a nested scope +PASS: gdb.cp/nsusing.exp: print cc +PASS: gdb.cp/nsusing.exp: print B::_a +PASS: gdb.cp/nsusing.exp: print _a in namespace alias scope +PASS: gdb.cp/nsusing.exp: print x in namespace alias scope +PASS: gdb.cp/nsusing.exp: Print _a without import +PASS: gdb.cp/nsusing.exp: print dx +PASS: gdb.cp/nsusing.exp: print efx +PASS: gdb.cp/nsusing.exp: print ghx +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: K::marker9 +PASS: gdb.cp/nsusing.exp: print jx +PASS: gdb.cp/nsusing.exp: continue to breakpoint: marker10 stop +PASS: gdb.cp/nsusing.exp: print x (from M::x) +Running ./gdb.cp/operator.exp ... +PASS: gdb.cp/operator.exp: global operator +PASS: gdb.cp/operator.exp: global operator overload +PASS: gdb.cp/operator.exp: ADL operator +PASS: gdb.cp/operator.exp: ADL operator overload +PASS: gdb.cp/operator.exp: Fully qualified explicit operator call +PASS: gdb.cp/operator.exp: anonymous namespace operator +PASS: gdb.cp/operator.exp: anonymous namespace operator overload +PASS: gdb.cp/operator.exp: anonymous namespace operator overload float +PASS: gdb.cp/operator.exp: imported operator +PASS: gdb.cp/operator.exp: imported operator overload +PASS: gdb.cp/operator.exp: imported operator overload float +PASS: gdb.cp/operator.exp: member operator +PASS: gdb.cp/operator.exp: member operator overload +PASS: gdb.cp/operator.exp: namespace alias +PASS: gdb.cp/operator.exp: imported declaration +PASS: gdb.cp/operator.exp: p l == 1 +PASS: gdb.cp/operator.exp: p x[0] +Running ./gdb.cp/oranking.exp ... +PASS: gdb.cp/oranking.exp: continue to breakpoint: end of main +KFAIL: gdb.cp/oranking.exp: p foo0(b) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test1() +PASS: gdb.cp/oranking.exp: p foo1(b) +PASS: gdb.cp/oranking.exp: p test2() +KFAIL: gdb.cp/oranking.exp: p foo2(b) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test3() +PASS: gdb.cp/oranking.exp: p foo3(1.0f) +PASS: gdb.cp/oranking.exp: p test4() +KFAIL: gdb.cp/oranking.exp: p foo4(&a) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test5() +PASS: gdb.cp/oranking.exp: p foo5(c) +PASS: gdb.cp/oranking.exp: p test6() +PASS: gdb.cp/oranking.exp: p foo6(bp) +PASS: gdb.cp/oranking.exp: p test7() +PASS: gdb.cp/oranking.exp: p foo7(cp) +PASS: gdb.cp/oranking.exp: p test8() +PASS: gdb.cp/oranking.exp: p foo8(co) +PASS: gdb.cp/oranking.exp: p test9() +PASS: gdb.cp/oranking.exp: p foo9(co) +PASS: gdb.cp/oranking.exp: p test10() +KFAIL: gdb.cp/oranking.exp: p foo10(amp) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test101() +KFAIL: gdb.cp/oranking.exp: p foo101("abc") (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test11() +KFAIL: gdb.cp/oranking.exp: p foo11(d) (PRMS: gdb/12096) +PASS: gdb.cp/oranking.exp: p test12() +PASS: gdb.cp/oranking.exp: p foo12(1) +PASS: gdb.cp/oranking.exp: p test13() +KFAIL: gdb.cp/oranking.exp: p foo13(c) (PRMS: gdb/12098) +PASS: gdb.cp/oranking.exp: p test14() +KFAIL: gdb.cp/oranking.exp: p foo14(e) (PRMS: gdb/12096) +Running ./gdb.cp/overload-const.exp ... +PASS: gdb.cp/overload-const.exp: set language c++ +PASS: gdb.cp/overload-const.exp: setting breakpoint at myclass::func +Running ./gdb.cp/overload.exp ... +PASS: gdb.cp/overload.exp: up from marker1 +PASS: gdb.cp/overload.exp: print foo_instance1 +PASS: gdb.cp/overload.exp: ptype foo_instance1 (shorter match) +PASS: gdb.cp/overload.exp: print foo_instance2 +PASS: gdb.cp/overload.exp: print foo_instance3 +PASS: gdb.cp/overload.exp: print call overloaded func 1 arg +PASS: gdb.cp/overload.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/overload.exp: print call overloaded func 2 args +PASS: gdb.cp/overload.exp: print call overloaded func 3 args +PASS: gdb.cp/overload.exp: print call overloaded func 4 args +PASS: gdb.cp/overload.exp: print call overloaded func 5 args +PASS: gdb.cp/overload.exp: print call overloaded func 6 args +PASS: gdb.cp/overload.exp: print call overloaded func 7 args +PASS: gdb.cp/overload.exp: print call overloaded func 8 args +PASS: gdb.cp/overload.exp: print call overloaded func 9 args +PASS: gdb.cp/overload.exp: print call overloaded func 10 args +PASS: gdb.cp/overload.exp: print call overloaded func 11 args +PASS: gdb.cp/overload.exp: print call overloaded func void arg +PASS: gdb.cp/overload.exp: print call overloaded func char arg +PASS: gdb.cp/overload.exp: print call overloaded func signed char arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned char arg +PASS: gdb.cp/overload.exp: print call overloaded func short arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned short arg +PASS: gdb.cp/overload.exp: print call overloaded func int arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned int arg +PASS: gdb.cp/overload.exp: print call overloaded func long arg +PASS: gdb.cp/overload.exp: print call overloaded func unsigned long arg +PASS: gdb.cp/overload.exp: print call overloaded func float arg +PASS: gdb.cp/overload.exp: print call overloaded func double arg +PASS: gdb.cp/overload.exp: print call overloaded func int\* arg +PASS: gdb.cp/overload.exp: print call overloaded func char\* arg +PASS: gdb.cp/overload.exp: print bar(a) +PASS: gdb.cp/overload.exp: print bar(b) +PASS: gdb.cp/overload.exp: print bar(c) +PASS: gdb.cp/overload.exp: print bar(d) +PASS: gdb.cp/overload.exp: list overloaded function with no args +PASS: gdb.cp/overload.exp: list overloaded function with int arg +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args +PASS: gdb.cp/overload.exp: list overloaded function with function ptr args - quotes around argument +PASS: gdb.cp/overload.exp: list overload.cc:intToChar +PASS: gdb.cp/overload.exp: list overload.cc:intToChar(char) +PASS: gdb.cp/overload.exp: list overload.cc:'intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc:intToChar(char)' +PASS: gdb.cp/overload.exp: list 'overload.cc':intToChar(char) +PASS: gdb.cp/overload.exp: list 'overload.cc':'intToChar(char)' +PASS: gdb.cp/overload.exp: list overload.cc:foo::overloadfnarg(int) +PASS: gdb.cp/overload.exp: list overload.cc:'foo::overloadfnarg(int)' +PASS: gdb.cp/overload.exp: print overloadNamespace(1) +PASS: gdb.cp/overload.exp: print overloadNamespace('a') +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) +PASS: gdb.cp/overload.exp: print K::staticoverload () +PASS: gdb.cp/overload.exp: print K::staticoverload (2) +PASS: gdb.cp/overload.exp: print K::staticoverload (2, 3) +PASS: gdb.cp/overload.exp: print N::nsoverload () +PASS: gdb.cp/overload.exp: print N::nsoverload (2) +PASS: gdb.cp/overload.exp: print N::nsoverload (2, 3) +PASS: gdb.cp/overload.exp: print overloadNamespace(1) in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace('a') in XXX +PASS: gdb.cp/overload.exp: print overloadNamespace(dummyInstance) in XXX +PASS: gdb.cp/overload.exp: print intToChar(1) +PASS: gdb.cp/overload.exp: print foo::overload1arg +PASS: gdb.cp/overload.exp: print foo::overload1arg(char***) +PASS: gdb.cp/overload.exp: print foo::overload1arg(void) +PASS: gdb.cp/overload.exp: print foo::overload1arg(char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(signed char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned char) +PASS: gdb.cp/overload.exp: print foo::overload1arg(short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned short) +PASS: gdb.cp/overload.exp: print foo::overload1arg(int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned int) +PASS: gdb.cp/overload.exp: print foo::overload1arg(long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(unsigned long) +PASS: gdb.cp/overload.exp: print foo::overload1arg(float) +PASS: gdb.cp/overload.exp: print foo::overload1arg(double) +Running ./gdb.cp/ovldbreak.exp ... +PASS: gdb.cp/ovldbreak.exp: detect void +PASS: gdb.cp/ovldbreak.exp: detect char +PASS: gdb.cp/ovldbreak.exp: detect signed_char +PASS: gdb.cp/ovldbreak.exp: detect unsigned_char +PASS: gdb.cp/ovldbreak.exp: detect short_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: detect int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_int +PASS: gdb.cp/ovldbreak.exp: detect long_int +PASS: gdb.cp/ovldbreak.exp: detect unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: detect float +PASS: gdb.cp/ovldbreak.exp: detect double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols ask +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 2 +PASS: gdb.cp/ovldbreak.exp: set bp 2 on foo::overload1arg 2 line 107 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 3 +PASS: gdb.cp/ovldbreak.exp: set bp 3 on foo::overload1arg 3 line 110 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 4 +PASS: gdb.cp/ovldbreak.exp: set bp 4 on foo::overload1arg 4 line 140 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 5 +PASS: gdb.cp/ovldbreak.exp: set bp 5 on foo::overload1arg 5 line 137 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 6 +PASS: gdb.cp/ovldbreak.exp: set bp 6 on foo::overload1arg 6 line 125 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 7 +PASS: gdb.cp/ovldbreak.exp: set bp 7 on foo::overload1arg 7 line 131 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 8 +PASS: gdb.cp/ovldbreak.exp: set bp 8 on foo::overload1arg 8 line 119 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 9 +PASS: gdb.cp/ovldbreak.exp: set bp 9 on foo::overload1arg 9 line 113 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 10 +PASS: gdb.cp/ovldbreak.exp: set bp 10 on foo::overload1arg 10 line 116 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 11 +PASS: gdb.cp/ovldbreak.exp: set bp 11 on foo::overload1arg 11 line 128 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 12 +PASS: gdb.cp/ovldbreak.exp: set bp 12 on foo::overload1arg 12 line 134 +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice 13 +PASS: gdb.cp/ovldbreak.exp: set bp 13 on foo::overload1arg 13 line 122 +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting one-by-one) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice cancel +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg canceled +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after cancel) +PASS: gdb.cp/ovldbreak.exp: delete all breakpoints +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after delete) +PASS: gdb.cp/ovldbreak.exp: bp menu for foo::overload1arg choice all +PASS: gdb.cp/ovldbreak.exp: set bp on overload1arg all +PASS: gdb.cp/ovldbreak.exp: breakpoint info (after setting on all) +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : void +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : signed_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_char +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_short_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : unsigned_long_int +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : float +PASS: gdb.cp/ovldbreak.exp: continue to bp overloaded : double +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols cancel +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +PASS: gdb.cp/ovldbreak.exp: set multiple-symbols all +PASS: gdb.cp/ovldbreak.exp: break foo::foofunc +PASS: gdb.cp/ovldbreak.exp: continue until exit at finish program +Running ./gdb.cp/ovsrch.exp ... +PASS: gdb.cp/ovsrch.exp: break A::stop_here +PASS: gdb.cp/ovsrch.exp: break 'A::stop_here' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::outer::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::outer::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::outer::hibob if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::stop_here_too +PASS: gdb.cp/ovsrch.exp: break 'A::B::stop_here_too' +PASS: gdb.cp/ovsrch.exp: continue to breakpoint: stop_here_too +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (char*) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (char*) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (void) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (void) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (a_param == 3) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::foo (int) const if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break 'A::B::inner::foo (int) const' if (A::outer::func ()) +PASS: gdb.cp/ovsrch.exp: break A::B::inner::hibob if (a_param == 3) +Running ./gdb.cp/paren-type.exp ... +PASS: gdb.cp/paren-type.exp: set breakpoint pending off +PASS: gdb.cp/paren-type.exp: break C::f(long) +PASS: gdb.cp/paren-type.exp: break C::f(short) +Running ./gdb.cp/parse-lang.exp ... +PASS: gdb.cp/parse-lang.exp: breakpoint hit +Running ./gdb.cp/pass-by-ref.exp ... +PASS: gdb.cp/pass-by-ref.exp: call function in obj +PASS: gdb.cp/pass-by-ref.exp: call function in derived +PASS: gdb.cp/pass-by-ref.exp: call function in container +Running ./gdb.cp/pr-1023.exp ... +PASS: gdb.cp/pr-1023.exp: break myClass::performBlocking +PASS: gdb.cp/pr-1023.exp: break myClass::performUnblocking +Running ./gdb.cp/pr10687.exp ... +PASS: gdb.cp/pr10687.exp: continue to breakpoint: marker +PASS: gdb.cp/pr10687.exp: p a +Running ./gdb.cp/pr10728.exp ... +PASS: gdb.cp/pr10728.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/pr10728.exp: print x->y2 - x->y1 +Running ./gdb.cp/pr12028.exp ... +PASS: gdb.cp/pr12028.exp: p D::foo(b) +Running ./gdb.cp/pr-1210.exp ... +PASS: gdb.cp/pr-1210.exp: step past initialization +PASS: gdb.cp/pr-1210.exp: print *obj +PASS: gdb.cp/pr-1210.exp: print obj->myB +Running ./gdb.cp/pr-574.exp ... +PASS: gdb.cp/pr-574.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/pr-574.exp: PR gdb/574 +Running ./gdb.cp/pr9067.exp ... +PASS: gdb.cp/pr9067.exp: print b +Running ./gdb.cp/pr9167.exp ... +PASS: gdb.cp/pr9167.exp: continue to breakpoint: marker +PASS: gdb.cp/pr9167.exp: p b +Running ./gdb.cp/pr9631.exp ... +PASS: gdb.cp/pr9631.exp: continue to breakpoint: after bar tender is initialized +PASS: gdb.cp/pr9631.exp: print tender +Running ./gdb.cp/printmethod.exp ... +PASS: gdb.cp/printmethod.exp: continue to breakpoint: end of constructors +PASS: gdb.cp/printmethod.exp: print virtual method. +PASS: gdb.cp/printmethod.exp: print nonvirtual method. +Running ./gdb.cp/psmang.exp ... +PASS: gdb.cp/psmang.exp: break s::method1 +PASS: gdb.cp/psmang.exp: break s::method2 +Running ./gdb.cp/psymtab-parameter.exp ... +PASS: gdb.cp/psymtab-parameter.exp: set language c++ +PASS: gdb.cp/psymtab-parameter.exp: maintenance info symtabs +PASS: gdb.cp/psymtab-parameter.exp: complete p 'func<short>( +Running ./gdb.cp/ptype-cv-cp.exp ... +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_const_volatile_my_int +PASS: gdb.cp/ptype-cv-cp.exp: whatis v_volatile_const_my_int +PASS: gdb.cp/ptype-cv-cp.exp: ptype v_volatile_const_my_int +Running ./gdb.cp/ptype-flags.exp ... +PASS: gdb.cp/ptype-flags.exp: basic test +PASS: gdb.cp/ptype-flags.exp: no methods +PASS: gdb.cp/ptype-flags.exp: no typedefs +PASS: gdb.cp/ptype-flags.exp: no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: raw +PASS: gdb.cp/ptype-flags.exp: raw no methods +PASS: gdb.cp/ptype-flags.exp: raw no typedefs +PASS: gdb.cp/ptype-flags.exp: raw no methods or typedefs +PASS: gdb.cp/ptype-flags.exp: set print type methods off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, default methods off +PASS: gdb.cp/ptype-flags.exp: no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: methods, no typedefs, default methods off +PASS: gdb.cp/ptype-flags.exp: set print type typedefs off +PASS: gdb.cp/ptype-flags.exp: basic test, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: typedefs, default methods+typedefs off +PASS: gdb.cp/ptype-flags.exp: methods typedefs, default methods+typedefs off +Running ./gdb.cp/punctuator.exp ... +PASS: gdb.cp/punctuator.exp: set lang c++ +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitand 0xaaaa) == (0x5a5a & 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a bitor 0xaaaa) == (0x5a5a | 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a xor 0xaaaa) == (0x5a5a ^ 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a and 0xaaaa) == (0x5a5a && 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (0x5a5a or 0xaaaa) == (0x5a5a || 0xaaaa) +PASS: gdb.cp/punctuator.exp: print (not not 0xaaaa) == (!!0xaaaa) +PASS: gdb.cp/punctuator.exp: print (compl 0xaaaa) == (~0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 1 +PASS: gdb.cp/punctuator.exp: set $v 1 +PASS: gdb.cp/punctuator.exp: print ($u not_eq 0xaaaa) == ($v != 0xaaaa) +PASS: gdb.cp/punctuator.exp: print ($u and_eq 0xaaaa) == ($v &= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 2 +PASS: gdb.cp/punctuator.exp: set $v 2 +PASS: gdb.cp/punctuator.exp: print ($u or_eq 0xaaaa) == ($v |= 0xaaaa) +PASS: gdb.cp/punctuator.exp: set $u 3 +PASS: gdb.cp/punctuator.exp: set $v 3 +PASS: gdb.cp/punctuator.exp: print ($u xor_eq 0xaaaa) == ($v ^= 0xaaaa) +Running ./gdb.cp/readnow-language.exp ... +PASS: gdb.cp/readnow-language.exp: show language +Running ./gdb.cp/ref-params.exp ... +PASS: gdb.cp/ref-params.exp: print value of a Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f2 on Child in main +PASS: gdb.cp/ref-params.exp: print value of f1 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of f2 on (Child&) in main +PASS: gdb.cp/ref-params.exp: print value of Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of f1 on Child& in f2 +PASS: gdb.cp/ref-params.exp: print value of Parent& in f1 +PASS: gdb.cp/ref-params.exp: print f1(MQ) +PASS: gdb.cp/ref-params.exp: print mf1(MQ) +PASS: gdb.cp/ref-params.exp: print mf2(MQ) +PASS: gdb.cp/ref-params.exp: print f1(MQR) +PASS: gdb.cp/ref-params.exp: print mf1(MQR) +PASS: gdb.cp/ref-params.exp: print mf2(MQR) +Running ./gdb.cp/ref-types.exp ... +PASS: gdb.cp/ref-types.exp: up from marker1 1 +PASS: gdb.cp/ref-types.exp: print value of s +PASS: gdb.cp/ref-types.exp: ptype s +PASS: gdb.cp/ref-types.exp: print value of ps +PASS: gdb.cp/ref-types.exp: ptype ps +PASS: gdb.cp/ref-types.exp: print value of as[0] +PASS: gdb.cp/ref-types.exp: ptype as +PASS: gdb.cp/ref-types.exp: print value of as[1] +PASS: gdb.cp/ref-types.exp: print value of as[2] +PASS: gdb.cp/ref-types.exp: print value of as[3] +PASS: gdb.cp/ref-types.exp: print value of rs +PASS: gdb.cp/ref-types.exp: ptype rs +PASS: gdb.cp/ref-types.exp: print value of *rps +PASS: gdb.cp/ref-types.exp: examine value at rps +PASS: gdb.cp/ref-types.exp: ptype rps +PASS: gdb.cp/ref-types.exp: print value of ras[0] +PASS: gdb.cp/ref-types.exp: ptype ras +PASS: gdb.cp/ref-types.exp: print value of ras[1] +PASS: gdb.cp/ref-types.exp: print value of ras[2] +PASS: gdb.cp/ref-types.exp: print value of ras[3] +PASS: gdb.cp/ref-types.exp: up from f +PASS: gdb.cp/ref-types.exp: print value of C +PASS: gdb.cp/ref-types.exp: ptype C +PASS: gdb.cp/ref-types.exp: print value of UC +PASS: gdb.cp/ref-types.exp: ptype UC +PASS: gdb.cp/ref-types.exp: print value of S +PASS: gdb.cp/ref-types.exp: ptype S +PASS: gdb.cp/ref-types.exp: print value of US +PASS: gdb.cp/ref-types.exp: ptype US +PASS: gdb.cp/ref-types.exp: print value of I +PASS: gdb.cp/ref-types.exp: ptype I +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: ptype UI +PASS: gdb.cp/ref-types.exp: print value of L +PASS: gdb.cp/ref-types.exp: ptype L +PASS: gdb.cp/ref-types.exp: print value of UL +PASS: gdb.cp/ref-types.exp: ptype UL +PASS: gdb.cp/ref-types.exp: print value of F +PASS: gdb.cp/ref-types.exp: ptype F +PASS: gdb.cp/ref-types.exp: print value of D +PASS: gdb.cp/ref-types.exp: ptype D +PASS: gdb.cp/ref-types.exp: ptype rC +PASS: gdb.cp/ref-types.exp: ptype rUC +PASS: gdb.cp/ref-types.exp: ptype rS +PASS: gdb.cp/ref-types.exp: ptype rUS +PASS: gdb.cp/ref-types.exp: ptype rI +PASS: gdb.cp/ref-types.exp: ptype rUI +PASS: gdb.cp/ref-types.exp: ptype rL +PASS: gdb.cp/ref-types.exp: ptype rUL +PASS: gdb.cp/ref-types.exp: ptype rF +PASS: gdb.cp/ref-types.exp: ptype rD +PASS: gdb.cp/ref-types.exp: print value of rC +PASS: gdb.cp/ref-types.exp: print value of rUC +PASS: gdb.cp/ref-types.exp: print value of rS +PASS: gdb.cp/ref-types.exp: print value of rUS +PASS: gdb.cp/ref-types.exp: print value of rI +PASS: gdb.cp/ref-types.exp: print value of UI +PASS: gdb.cp/ref-types.exp: print value of rL +PASS: gdb.cp/ref-types.exp: print value of rUL +PASS: gdb.cp/ref-types.exp: print value of rF +PASS: gdb.cp/ref-types.exp: print value of rD +Running ./gdb.cp/re-set-overloaded.exp ... +PASS: gdb.cp/re-set-overloaded.exp: set breakpoint pending yes +PASS: gdb.cp/re-set-overloaded.exp: break C::C +PASS: gdb.cp/re-set-overloaded.exp: set variable $brk = $bpnum +PASS: gdb.cp/re-set-overloaded.exp: start +PASS: gdb.cp/re-set-overloaded.exp: breakpoint resolved +Running ./gdb.cp/rtti.exp ... +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in main +PASS: gdb.cp/rtti.exp: print *e1 +PASS: gdb.cp/rtti.exp: print *e2 +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func +PASS: gdb.cp/rtti.exp: print *obj +PASS: gdb.cp/rtti.exp: continue to breakpoint: end of constructors in func3 +PASS: gdb.cp/rtti.exp: print *obj3 +Running ./gdb.cp/shadow.exp ... +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker1 +PASS: gdb.cp/shadow.exp: Print class x shadowing global x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker2 +PASS: gdb.cp/shadow.exp: Print local x shadowing class x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker3 +PASS: gdb.cp/shadow.exp: Print inner scope x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker4 +PASS: gdb.cp/shadow.exp: Print local x not namespace x +PASS: gdb.cp/shadow.exp: continue to breakpoint: marker5 +PASS: gdb.cp/shadow.exp: Print imported namespace x +Running ./gdb.cp/smartp.exp ... +PASS: gdb.cp/smartp.exp: continue to breakpoint: end of main +PASS: gdb.cp/smartp.exp: p mp->foo() +PASS: gdb.cp/smartp.exp: p mtp->foo() +PASS: gdb.cp/smartp.exp: p mt1.foo() +PASS: gdb.cp/smartp.exp: p mt4p.a +PASS: gdb.cp/smartp.exp: p mt4->a +PASS: gdb.cp/smartp.exp: p sp1->foo() +PASS: gdb.cp/smartp.exp: p sp2->foo() +PASS: gdb.cp/smartp.exp: p sp3->foo(1) +PASS: gdb.cp/smartp.exp: p sp3->foo('a') +PASS: gdb.cp/smartp.exp: p sp4->a +PASS: gdb.cp/smartp.exp: p sp4->b +PASS: gdb.cp/smartp.exp: p mt4p->a +PASS: gdb.cp/smartp.exp: p mt4p->b +PASS: gdb.cp/smartp.exp: p mt4->fake +PASS: gdb.cp/smartp.exp: p mt4->fake() +PASS: gdb.cp/smartp.exp: p b->foo() +PASS: gdb.cp/smartp.exp: p c->foo() +PASS: gdb.cp/smartp.exp: p c->inta +KFAIL: gdb.cp/smartp.exp: p c2->inta (PRMS: gdb/11606) +Running ./gdb.cp/static-method.exp ... +PASS: gdb.cp/static-method.exp: info addr A::func() +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: list 'static-method.cc:xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list 'static-method.cc':'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: list static-method.cc:'xxx::(anonymous namespace)::A::func' +PASS: gdb.cp/static-method.exp: continue to xxx::(anonymous namespace)::A::func +PASS: gdb.cp/static-method.exp: continue to 'xxx::(anonymous namespace)::A::func' +Running ./gdb.cp/static-print-quit.exp ... +PASS: gdb.cp/static-print-quit.exp: set width 80 +PASS: gdb.cp/static-print-quit.exp: set height 2 +PASS: gdb.cp/static-print-quit.exp: print c - <return> +PASS: gdb.cp/static-print-quit.exp: print c - q <return> +PASS: gdb.cp/static-print-quit.exp: print c - to quit +PASS: gdb.cp/static-print-quit.exp: q +PASS: gdb.cp/static-print-quit.exp: set pagination off +PASS: gdb.cp/static-print-quit.exp: first print +PASS: gdb.cp/static-print-quit.exp: second print +Running ./gdb.cp/temargs.exp ... +PASS: gdb.cp/temargs.exp: set first breakpoint for temargs +PASS: gdb.cp/temargs.exp: set second breakpoint for temargs +PASS: gdb.cp/temargs.exp: set third breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: set sixth breakpoint for temargs +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to first breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in base_m +PASS: gdb.cp/temargs.exp: test value of I in base_m +PASS: gdb.cp/temargs.exp: test value of P in base_m +PASS: gdb.cp/temargs.exp: test value of MP in base_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to second breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in inner_m +PASS: gdb.cp/temargs.exp: test value of I in inner_m +PASS: gdb.cp/temargs.exp: test value of P in inner_m +PASS: gdb.cp/temargs.exp: test value of MP in inner_m +PASS: gdb.cp/temargs.exp: test type of Z in inner_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to third breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in func +PASS: gdb.cp/temargs.exp: test value of I in func +PASS: gdb.cp/temargs.exp: test value of P in func +PASS: gdb.cp/temargs.exp: test value of MP in func +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fourth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of T in templ_m +PASS: gdb.cp/temargs.exp: test value of I in templ_m +PASS: gdb.cp/temargs.exp: test value of P in templ_m +PASS: gdb.cp/temargs.exp: test value of MP in templ_m +PASS: gdb.cp/temargs.exp: test type of Q in templ_m +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to fifth breakpoint for temargs +PASS: gdb.cp/temargs.exp: test type of F in k2_m +XFAIL: gdb.cp/temargs.exp: test value of F in k2_m (PRMS gcc/49366) +PASS: gdb.cp/temargs.exp: continue to breakpoint: continue to sixth breakpoint for temargs +XFAIL: gdb.cp/temargs.exp: test type of F in k3_m (PRMS gcc/49546) +XFAIL: gdb.cp/temargs.exp: test value of F in k3_m (PRMS gcc/49546) +Running ./gdb.cp/templates.exp ... +PASS: gdb.cp/templates.exp: set multiple-symbols ask +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +KFAIL: gdb.cp/templates.exp: ptype T5<int> (PRMS: gdb/8218) +PASS: gdb.cp/templates.exp: constructor breakpoint +PASS: gdb.cp/templates.exp: destructor breakpoint +PASS: gdb.cp/templates.exp: value method breakpoint +PASS: gdb.cp/templates.exp: breakpoint on a line with no real code +PASS: gdb.cp/templates.exp: print method of template typedef +XFAIL: gdb.cp/templates.exp: print destructor of template typedef (PRMS gcc/51668) +PASS: gdb.cp/templates.exp: verify GCC PR debug/51668 +PASS: gdb.cp/templates.exp: ptype empty +PASS: gdb.cp/templates.exp: ptype arg +PASS: gdb.cp/templates.exp: print t5i.value() +PASS: gdb.cp/templates.exp: b 770 +PASS: gdb.cp/templates.exp: continue to line 770 +PASS: gdb.cp/templates.exp: print fint +PASS: gdb.cp/templates.exp: print fvpchar +PASS: gdb.cp/templates.exp: ptype Foo +PASS: gdb.cp/templates.exp: ptype fint +PASS: gdb.cp/templates.exp: ptype fchar +KFAIL: gdb.cp/templates.exp: ptype fvpchar (PRMS: gdb/1512) +PASS: gdb.cp/templates.exp: print Foo<volatile char *>::foo +PASS: gdb.cp/templates.exp: print Foo<volatile char*>::foo +PASS: gdb.cp/templates.exp: ptype Bar +PASS: gdb.cp/templates.exp: ptype bint +PASS: gdb.cp/templates.exp: ptype bint2 +PASS: gdb.cp/templates.exp: ptype Baz +PASS: gdb.cp/templates.exp: ptype bazint +PASS: gdb.cp/templates.exp: ptype bazint2 +PASS: gdb.cp/templates.exp: ptype Qux +PASS: gdb.cp/templates.exp: ptype quxint +PASS: gdb.cp/templates.exp: ptype Spec +PASS: gdb.cp/templates.exp: ptype siip +PASS: gdb.cp/templates.exp: ptype Garply<int> +PASS: gdb.cp/templates.exp: ptype Garply<Garply<char> > +PASS: gdb.cp/templates.exp: print Garply<Garply<char> >::garply +PASS: gdb.cp/templates.exp: break Garply<Garply<char> >::garply +Running ./gdb.cp/try_catch.exp ... +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 1-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-start +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-next +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 2-catch +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-throw +PASS: gdb.cp/try_catch.exp: continue to breakpoint: marker 3-catch +Running ./gdb.cp/typedef-operator.exp ... +PASS: gdb.cp/typedef-operator.exp: set language c++ +PASS: gdb.cp/typedef-operator.exp: test crash +PASS: gdb.cp/typedef-operator.exp: test typedef +Running ./gdb.cp/userdef.exp ... +PASS: gdb.cp/userdef.exp: break marker1 +PASS: gdb.cp/userdef.exp: continue to marker1 +PASS: gdb.cp/userdef.exp: up from marker1 +PASS: gdb.cp/userdef.exp: print one + two +PASS: gdb.cp/userdef.exp: re-selected 'main' frame after inferior call +PASS: gdb.cp/userdef.exp: print one - two +PASS: gdb.cp/userdef.exp: print one * two +PASS: gdb.cp/userdef.exp: print one / two +PASS: gdb.cp/userdef.exp: print one % two +PASS: gdb.cp/userdef.exp: print one && two +PASS: gdb.cp/userdef.exp: print one || two +PASS: gdb.cp/userdef.exp: print one & two +PASS: gdb.cp/userdef.exp: print one | two +PASS: gdb.cp/userdef.exp: print one ^ two +PASS: gdb.cp/userdef.exp: print one < two +PASS: gdb.cp/userdef.exp: print one <= two +PASS: gdb.cp/userdef.exp: print one > two +PASS: gdb.cp/userdef.exp: print one >= two +PASS: gdb.cp/userdef.exp: print one == two +PASS: gdb.cp/userdef.exp: print one.operator== (two) +PASS: gdb.cp/userdef.exp: print one != two +PASS: gdb.cp/userdef.exp: print one << 31 +PASS: gdb.cp/userdef.exp: print one >> 31 +PASS: gdb.cp/userdef.exp: print !one +PASS: gdb.cp/userdef.exp: print +one +PASS: gdb.cp/userdef.exp: print ~one +PASS: gdb.cp/userdef.exp: print -one +PASS: gdb.cp/userdef.exp: print one++ +PASS: gdb.cp/userdef.exp: print ++one +PASS: gdb.cp/userdef.exp: print one-- +PASS: gdb.cp/userdef.exp: print --one +PASS: gdb.cp/userdef.exp: print one += 7 +PASS: gdb.cp/userdef.exp: print two = one +PASS: gdb.cp/userdef.exp: break A2::operator+ +PASS: gdb.cp/userdef.exp: break A2::operator + +PASS: gdb.cp/userdef.exp: print c +PASS: gdb.cp/userdef.exp: print *c +PASS: gdb.cp/userdef.exp: print &*c +PASS: gdb.cp/userdef.exp: ptype &*c +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem2) +PASS: gdb.cp/userdef.exp: print operator== (mem1, mem1) +Running ./gdb.cp/using-crash.exp ... +PASS: gdb.cp/using-crash.exp: reload file +Running ./gdb.cp/virtbase.exp ... +PASS: gdb.cp/virtbase.exp: continue to breakpoint: first breakpoint +PASS: gdb.cp/virtbase.exp: print *this +PASS: gdb.cp/virtbase.exp: print x in get_y +PASS: gdb.cp/virtbase.exp: continue to breakpoint: second breakpoint +PASS: gdb.cp/virtbase.exp: print x in get_z +PASS: gdb.cp/virtbase.exp: continue to breakpoint: third breakpoint +PASS: gdb.cp/virtbase.exp: print *(D *) e +PASS: gdb.cp/virtbase.exp: set print object on +PASS: gdb.cp/virtbase.exp: print/x b->mA +PASS: gdb.cp/virtbase.exp: print rtti_data +PASS: gdb.cp/virtbase.exp: print pointer to virtual base at non-zero offset of larger object +PASS: gdb.cp/virtbase.exp: print same pointer from history value +PASS: gdb.cp/virtbase.exp: print whole pointed-to object, starting from the virtual base pointer +Running ./gdb.cp/virtfunc2.exp ... +PASS: gdb.cp/virtfunc2.exp: continue to breakpoint: marker 1 +PASS: gdb.cp/virtfunc2.exp: print o.do_print() +PASS: gdb.cp/virtfunc2.exp: print o.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print2() +PASS: gdb.cp/virtfunc2.exp: print o2.do_print3() +PASS: gdb.cp/virtfunc2.exp: print o +Running ./gdb.cp/virtfunc.exp ... +PASS: gdb.cp/virtfunc.exp: ptype VA +PASS: gdb.cp/virtfunc.exp: ptype VB +PASS: gdb.cp/virtfunc.exp: ptype V +PASS: gdb.cp/virtfunc.exp: ptype A +PASS: gdb.cp/virtfunc.exp: ptype B +PASS: gdb.cp/virtfunc.exp: ptype C +PASS: gdb.cp/virtfunc.exp: ptype AD +PASS: gdb.cp/virtfunc.exp: ptype D +PASS: gdb.cp/virtfunc.exp: ptype E +PASS: gdb.cp/virtfunc.exp: ptype dd +PASS: gdb.cp/virtfunc.exp: ptype ppd +PASS: gdb.cp/virtfunc.exp: ptype pAd +PASS: gdb.cp/virtfunc.exp: ptype a +PASS: gdb.cp/virtfunc.exp: ptype b +PASS: gdb.cp/virtfunc.exp: ptype c +PASS: gdb.cp/virtfunc.exp: ptype d +PASS: gdb.cp/virtfunc.exp: ptype e +PASS: gdb.cp/virtfunc.exp: ptype v +PASS: gdb.cp/virtfunc.exp: ptype vb +PASS: gdb.cp/virtfunc.exp: ptype pAa +PASS: gdb.cp/virtfunc.exp: ptype pAe +PASS: gdb.cp/virtfunc.exp: ptype pBe +PASS: gdb.cp/virtfunc.exp: ptype pDd +PASS: gdb.cp/virtfunc.exp: ptype pDe +PASS: gdb.cp/virtfunc.exp: ptype pVa +PASS: gdb.cp/virtfunc.exp: ptype pVv +PASS: gdb.cp/virtfunc.exp: ptype pVe +PASS: gdb.cp/virtfunc.exp: ptype pVd +PASS: gdb.cp/virtfunc.exp: ptype pADe +PASS: gdb.cp/virtfunc.exp: ptype pEe +PASS: gdb.cp/virtfunc.exp: ptype pVB +PASS: gdb.cp/virtfunc.exp: info vtbl a +PASS: gdb.cp/virtfunc.exp: info vtbl b +PASS: gdb.cp/virtfunc.exp: info vtbl c +PASS: gdb.cp/virtfunc.exp: info vtbl d +PASS: gdb.cp/virtfunc.exp: info vtbl e +PASS: gdb.cp/virtfunc.exp: info vtbl pEe +PASS: gdb.cp/virtfunc.exp: info vtbl +PASS: gdb.cp/virtfunc.exp: info vtbl va +PASS: gdb.cp/virtfunc.exp: info vtbl all_count +PASS: gdb.cp/virtfunc.exp: print pAe->f() +PASS: gdb.cp/virtfunc.exp: print pAa->f() +PASS: gdb.cp/virtfunc.exp: print pDe->vg() +PASS: gdb.cp/virtfunc.exp: print pADe->vg() +PASS: gdb.cp/virtfunc.exp: print pDd->vg() +PASS: gdb.cp/virtfunc.exp: print pEe->vvb() +PASS: gdb.cp/virtfunc.exp: print pVB->vvb() +PASS: gdb.cp/virtfunc.exp: print pBe->vvb() +PASS: gdb.cp/virtfunc.exp: print pDe->vvb() +PASS: gdb.cp/virtfunc.exp: print pEe->vd() +PASS: gdb.cp/virtfunc.exp: print pEe->fvb() +KFAIL: gdb.cp/virtfunc.exp: print pEe->D::vg() (PRMS: gdb/1064) +PASS: gdb.cp/virtfunc.exp: next to pAa->f call +PASS: gdb.cp/virtfunc.exp: next to pDe->vg call +PASS: gdb.cp/virtfunc.exp: step through thunk into E::vg +Running ./gdb.disasm/am33.exp ... +Running ./gdb.disasm/h8300s.exp ... +Running ./gdb.disasm/hppa.exp ... +Running ./gdb.disasm/mn10300.exp ... +Running ./gdb.disasm/sh3.exp ... +Running ./gdb.disasm/t01_mov.exp ... +Running ./gdb.disasm/t02_mova.exp ... +Running ./gdb.disasm/t03_add.exp ... +Running ./gdb.disasm/t04_sub.exp ... +Running ./gdb.disasm/t05_cmp.exp ... +Running ./gdb.disasm/t06_ari2.exp ... +Running ./gdb.disasm/t07_ari3.exp ... +Running ./gdb.disasm/t08_or.exp ... +Running ./gdb.disasm/t09_xor.exp ... +Running ./gdb.disasm/t10_and.exp ... +Running ./gdb.disasm/t11_logs.exp ... +Running ./gdb.disasm/t12_bit.exp ... +Running ./gdb.disasm/t13_otr.exp ... +Running ./gdb.dwarf2/callframecfa.exp ... +Running ./gdb.dwarf2/clztest.exp ... +PASS: gdb.dwarf2/clztest.exp: set breakpoint at clztest.c:12 +PASS: gdb.dwarf2/clztest.exp: continue to breakpoint: continue to clztest.c:12 +PASS: gdb.dwarf2/clztest.exp: check value of g at clztest.c:12 +PASS: gdb.dwarf2/clztest.exp: check value of f at clztest.c:12 +PASS: gdb.dwarf2/clztest.exp: set breakpoint at clztest.c:22 +PASS: gdb.dwarf2/clztest.exp: continue to breakpoint: continue to clztest.c:22 +PASS: gdb.dwarf2/clztest.exp: check value of g at clztest.c:22 +PASS: gdb.dwarf2/clztest.exp: check value of f at clztest.c:22 +Running ./gdb.dwarf2/dup-psym.exp ... +PASS: gdb.dwarf2/dup-psym.exp: info sources should contain only one reference to file1.txt +Running ./gdb.dwarf2/dw2-ada-ffffffff.exp ... +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: p sizeof (t) +PASS: gdb.dwarf2/dw2-ada-ffffffff.exp: ptype t +Running ./gdb.dwarf2/dw2-anon-mptr.exp ... +PASS: gdb.dwarf2/dw2-anon-mptr.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-anon-mptr.exp: show cp-abi +PASS: gdb.dwarf2/dw2-anon-mptr.exp: ptype crash +Running ./gdb.dwarf2/dw2-anonymous-func.exp ... +PASS: gdb.dwarf2/dw2-anonymous-func.exp: list file1.txt +Running ./gdb.dwarf2/dw2-bad-parameter-type.exp ... +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: ptype f +PASS: gdb.dwarf2/dw2-bad-parameter-type.exp: is alive +Running ./gdb.dwarf2/dw2-basic.exp ... +PASS: gdb.dwarf2/dw2-basic.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-basic.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-basic.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-canonicalize-type.exp ... +PASS: gdb.dwarf2/dw2-canonicalize-type.exp: ptype f +Running ./gdb.dwarf2/dw2-case-insensitive.exp ... +PASS: gdb.dwarf2/dw2-case-insensitive.exp: show case-sensitive +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive on +PASS: gdb.dwarf2/dw2-case-insensitive.exp: set case-sensitive off +PASS: gdb.dwarf2/dw2-case-insensitive.exp: regexp case-sensitive off +PASS: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: p fuNC_symtab +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_lang +PASS: gdb.dwarf2/dw2-case-insensitive.exp: setting breakpoint at fuNC_symtab +Running ./gdb.dwarf2/dw2-common-block.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.dwarf2/dw2-common-block.exp: dw2-common-block.exp +Running ./gdb.dwarf2/dw2-compdir-oldgcc.exp ... +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc42 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: list gcc43 +PASS: gdb.dwarf2/dw2-compdir-oldgcc.exp: info source gcc43 +Running ./gdb.dwarf2/dw2-compressed.exp ... +PASS: gdb.dwarf2/dw2-compressed.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-compressed.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-compressed.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-const.exp ... +PASS: gdb.dwarf2/dw2-const.exp: print twelve +PASS: gdb.dwarf2/dw2-const.exp: print/x val8 +Running ./gdb.dwarf2/dw2-cp-infcall-ref-static.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-cp-infcall-ref-static.exp: dw2-cp-infcall-ref-static.exp +Running ./gdb.dwarf2/dw2-cu-size.exp ... +PASS: gdb.dwarf2/dw2-cu-size.exp: ptype noloc +Running ./gdb.dwarf2/dw2-dir-file-name.exp ... +PASS: gdb.dwarf2/dw2-dir-file-name.exp: cd .../rdir +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: continue to breakpoint: compdir_missing__ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: continue to breakpoint: compdir_missing__ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: continue to breakpoint: compdir_missing__ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: continue to breakpoint: compdir_missing__ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: continue to breakpoint: compdir_missing__ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: continue to breakpoint: compdir_missing__ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: continue to breakpoint: compdir_missing__ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: continue to breakpoint: compdir_missing__ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: continue to breakpoint: compdir_missing__ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_missing__ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: continue to breakpoint: compdir_relative_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: continue to breakpoint: compdir_relative_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: continue to breakpoint: compdir_relative_ldir_missing__file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_missing__file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: continue to breakpoint: compdir_relative_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: continue to breakpoint: compdir_relative_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: continue to breakpoint: compdir_relative_ldir_relative_file_absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_relative_file_absolute: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: continue to breakpoint: compdir_relative_ldir_absolute_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: continue to breakpoint: compdir_relative_ldir_absolute_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_relative_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_relative_ldir_absolute_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: continue to breakpoint: compdir_absolute_ldir_missing__file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: continue to breakpoint: compdir_absolute_ldir_missing__file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: continue to breakpoint: compdir_absolute_ldir_missing__file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_missing__file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: continue to breakpoint: compdir_absolute_ldir_relative_file_basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_basename: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: continue to breakpoint: compdir_absolute_ldir_relative_file_relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_relative: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_relative_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_relative_file_absolute_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_basename_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_basename_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_relative_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_relative_different: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_same +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_same: relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: continue to breakpoint: compdir_absolute_ldir_absolute_file_absolute_different +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: absolute +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: basename +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: set filename-display relative +PASS: gdb.dwarf2/dw2-dir-file-name.exp: compdir_absolute_ldir_absolute_file_absolute_different: relative +Running ./gdb.dwarf2/dw2-dos-drive.exp ... +PASS: gdb.dwarf2/dw2-dos-drive.exp: set breakpoint pending off +PASS: gdb.dwarf2/dw2-dos-drive.exp: break 'z:file.c':func +UNSUPPORTED: gdb.dwarf2/dw2-dos-drive.exp: break file.c:func +Running ./gdb.dwarf2/dw2-double-set-die-type.exp ... +PASS: gdb.dwarf2/dw2-double-set-die-type.exp: ptype a +Running ./gdb.dwarf2/dw2-empty-namespace.exp ... +PASS: gdb.dwarf2/dw2-empty-namespace.exp: ptype var +PASS: gdb.dwarf2/dw2-empty-namespace.exp: p var +Running ./gdb.dwarf2/dw2-empty-pc-range.exp ... +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range before CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: valid range after CU load +PASS: gdb.dwarf2/dw2-empty-pc-range.exp: empty range after CU load +Running ./gdb.dwarf2/dw2-entry-value.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-entry-value.exp: dw2-entry-value.exp +Running ./gdb.dwarf2/dw2-error.exp ... +PASS: gdb.dwarf2/dw2-error.exp: set breakpoint pending off +PASS: gdb.dwarf2/dw2-error.exp: file dw2-error +PASS: gdb.dwarf2/dw2-error.exp: break main +Running ./gdb.dwarf2/dw2-filename.exp ... +PASS: gdb.dwarf2/dw2-filename.exp: interpreter-exec mi -file-list-exec-source-files +PASS: gdb.dwarf2/dw2-filename.exp: info sources +Running ./gdb.dwarf2/dw2-icc-opaque.exp ... +PASS: gdb.dwarf2/dw2-icc-opaque.exp: ptype p_struct +Running ./gdb.dwarf2/dw2-ifort-parameter.exp ... +FAIL: gdb.dwarf2/dw2-ifort-parameter.exp: p/x param +Running ./gdb.dwarf2/dw2-inheritance.exp ... +PASS: gdb.dwarf2/dw2-inheritance.exp: ptype inherited +Running ./gdb.dwarf2/dw2-inline-break.exp ... +PASS: gdb.dwarf2/dw2-inline-break.exp: break func1 +PASS: gdb.dwarf2/dw2-inline-break.exp: break func2 +PASS: gdb.dwarf2/dw2-inline-break.exp: break func3b +PASS: gdb.dwarf2/dw2-inline-break.exp: break func4b +PASS: gdb.dwarf2/dw2-inline-break.exp: break func5b +PASS: gdb.dwarf2/dw2-inline-break.exp: break func6b +PASS: gdb.dwarf2/dw2-inline-break.exp: break func7b +PASS: gdb.dwarf2/dw2-inline-break.exp: break func8b +PASS: gdb.dwarf2/dw2-inline-break.exp: print func1 +PASS: gdb.dwarf2/dw2-inline-break.exp: print func2 +Running ./gdb.dwarf2/dw2-inline-param.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-inline-param.exp: dw2-inline-param.exp +Running ./gdb.dwarf2/dw2-intercu.exp ... +PASS: gdb.dwarf2/dw2-intercu.exp: ptype int2 +PASS: gdb.dwarf2/dw2-intercu.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-intercu.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-intercu.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-intermix.exp ... +PASS: gdb.dwarf2/dw2-intermix.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-intermix.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-intermix.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-linkage-name-trust.exp ... +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set language c++ +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername +PASS: gdb.dwarf2/dw2-linkage-name-trust.exp: p c.membername () +Running ./gdb.dwarf2/dw2-minsym-in-cu.exp ... +PASS: gdb.dwarf2/dw2-minsym-in-cu.exp: info fun func2 +Running ./gdb.dwarf2/dw2-modula2-self-type.exp ... +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: set language modula-2 +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: ptype v +PASS: gdb.dwarf2/dw2-modula2-self-type.exp: alive +Running ./gdb.dwarf2/dw2-namespaceless-anonymous.exp ... +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: ptype '(anonymous namespace)::v' +PASS: gdb.dwarf2/dw2-namespaceless-anonymous.exp: p '(anonymous namespace)::v' +Running ./gdb.dwarf2/dw2-noloc.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-noloc.exp: dw2-noloc.exp +Running ./gdb.dwarf2/dw2-objfile-overlap.exp ... +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: add-symbol-file +PASS: gdb.dwarf2/dw2-objfile-overlap.exp: info line inner +Running ./gdb.dwarf2/dw2-op-call.exp ... +PASS: gdb.dwarf2/dw2-op-call.exp: maintenance set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw2-op-call.exp: p array1 +PASS: gdb.dwarf2/dw2-op-call.exp: array2 using DW_OP_call2 +PASS: gdb.dwarf2/dw2-op-call.exp: array3 using DW_OP_call4 +PASS: gdb.dwarf2/dw2-op-call.exp: p arraynoloc +PASS: gdb.dwarf2/dw2-op-call.exp: p arraycallnoloc +Running ./gdb.dwarf2/dw2-op-out-param.exp ... +PASS: gdb.dwarf2/dw2-op-out-param.exp: set output-radix 16 +PASS: gdb.dwarf2/dw2-op-out-param.exp: set print frame-arguments all +PASS: gdb.dwarf2/dw2-op-out-param.exp: continue to breakpoint: Stop in breakpt for test int_param_single_reg_loc +PASS: gdb.dwarf2/dw2-op-out-param.exp: Backtrace for test int_param_single_reg_loc +PASS: gdb.dwarf2/dw2-op-out-param.exp: continue to breakpoint: Stop in breakpt for struct_param_single_reg_loc +KFAIL: gdb.dwarf2/dw2-op-out-param.exp: Backtrace for test struct_param_single_reg_loc (PRMS: symtab/14604) +PASS: gdb.dwarf2/dw2-op-out-param.exp: continue to breakpoint: Stop in breakpt for struct_param_two_reg_pieces +KFAIL: gdb.dwarf2/dw2-op-out-param.exp: Backtrace for test struct_param_two_reg_pieces (PRMS: symtab/14605) +PASS: gdb.dwarf2/dw2-op-out-param.exp: continue to breakpoint: Stop in breakpt for int_param_two_reg_pieces +KFAIL: gdb.dwarf2/dw2-op-out-param.exp: Backtrace for test int_param_two_reg_pieces (PRMS: symtab/14605) +Running ./gdb.dwarf2/dw2-op-stack-value.exp ... +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x stack8 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: x/wx &aa551234 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to2 +PASS: gdb.dwarf2/dw2-op-stack-value.exp: p/x implicit4to4 +Running ./gdb.dwarf2/dw2-param-error.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-param-error.exp: dw2-param-error.exp +Running ./gdb.dwarf2/dw2-producer.exp ... +PASS: gdb.dwarf2/dw2-producer.exp: set listsize 1 +PASS: gdb.dwarf2/dw2-producer.exp: list func_cu1 +PASS: gdb.dwarf2/dw2-producer.exp: ptype func_cu1 +Running ./gdb.dwarf2/dw2-ranges.exp ... +PASS: gdb.dwarf2/dw2-ranges.exp: info line main +PASS: gdb.dwarf2/dw2-ranges.exp: info line func +PASS: gdb.dwarf2/dw2-ranges.exp: info line main2 +PASS: gdb.dwarf2/dw2-ranges.exp: info line func2 +KFAIL: gdb.dwarf2/dw2-ranges.exp: info line main3 (PRMS: symtab/12497) +Running ./gdb.dwarf2/dw2-ref-missing-frame.exp ... +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb print +PASS: gdb.dwarf2/dw2-ref-missing-frame.exp: func_loopfb backtrace +Running ./gdb.dwarf2/dw2-restore.exp ... +PASS: gdb.dwarf2/dw2-restore.exp: continue +PASS: gdb.dwarf2/dw2-restore.exp: where +Running ./gdb.dwarf2/dw2-restrict.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.dwarf2/dw2-restrict0.o: requires unsupported dynamic reloc 11; recompile with -fPIC +/usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: error: /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.dwarf2/dw2-restrict0.o: requires dynamic R_X86_64_32 reloc which may overflow at runtime; recompile with -fPIC +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-restrict.exp: dw2-restrict.exp +Running ./gdb.dwarf2/dw2-simple-locdesc.exp ... +KFAIL: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.shl (PRMS: symtab/13307) +PASS: gdb.dwarf2/dw2-simple-locdesc.exp: p &s.data4 +Running ./gdb.dwarf2/dw2-skip-prologue.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-skip-prologue.exp: dw2-skip-prologue.exp +Running ./gdb.dwarf2/dw2-stack-boundary.exp ... +PASS: gdb.dwarf2/dw2-stack-boundary.exp: set complaints 100 +PASS: gdb.dwarf2/dw2-stack-boundary.exp: check partial symtab errors +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p underflow +PASS: gdb.dwarf2/dw2-stack-boundary.exp: p overflow +Running ./gdb.dwarf2/dw2-strp.exp ... +PASS: gdb.dwarf2/dw2-strp.exp: p a_string +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string +PASS: gdb.dwarf2/dw2-strp.exp: p a_string2 +PASS: gdb.dwarf2/dw2-strp.exp: ptype a_string2 +Running ./gdb.dwarf2/dw2-unresolved.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +UNTESTED: gdb.dwarf2/dw2-unresolved.exp: dw2-unresolved.exp +Running ./gdb.dwarf2/dw2-var-zero-addr.exp ... +PASS: gdb.dwarf2/dw2-var-zero-addr.exp: print &var +Running ./gdb.dwarf2/dw4-sig-types.exp ... +PASS: gdb.dwarf2/dw4-sig-types.exp: maint set dwarf2 max-cache-age 0 +PASS: gdb.dwarf2/dw4-sig-types.exp: p myset +PASS: gdb.dwarf2/dw4-sig-types.exp: continue to foo +Running ./gdb.dwarf2/dw4-sig-type-unused.exp ... +PASS: gdb.dwarf2/dw4-sig-type-unused.exp: alive +Running ./gdb.dwarf2/fission-base.exp ... +PASS: gdb.dwarf2/fission-base.exp: ptype main +PASS: gdb.dwarf2/fission-base.exp: ptype func +PASS: gdb.dwarf2/fission-base.exp: frame in main +PASS: gdb.dwarf2/fission-base.exp: break func +PASS: gdb.dwarf2/fission-base.exp: continue to func +PASS: gdb.dwarf2/fission-base.exp: frame in func +Running ./gdb.dwarf2/fission-loclists.exp ... +FAIL: gdb.dwarf2/fission-loclists.exp: p argc +Running ./gdb.dwarf2/fission-reread.exp ... +PASS: gdb.dwarf2/fission-reread.exp: break main +PASS: gdb.dwarf2/fission-reread.exp: fission-reread +PASS: gdb.dwarf2/fission-reread.exp: fission-reread - unload +Running ./gdb.dwarf2/implptr-64bit.exp ... +PASS: gdb.dwarf2/implptr-64bit.exp: d2o8a4r4t0 +PASS: gdb.dwarf2/implptr-64bit.exp: d2o4a8r8t0 +PASS: gdb.dwarf2/implptr-64bit.exp: d3o8a4r8t0 +PASS: gdb.dwarf2/implptr-64bit.exp: d3o4a8r4t0 +PASS: gdb.dwarf2/implptr-64bit.exp: d2o8a4r4t1 +PASS: gdb.dwarf2/implptr-64bit.exp: d2o4a8r8t1 +PASS: gdb.dwarf2/implptr-64bit.exp: d3o8a4r8t1 +PASS: gdb.dwarf2/implptr-64bit.exp: d3o4a8r4t1 +Running ./gdb.dwarf2/implptr.exp ... +Running ./gdb.dwarf2/implptr-optimized-out.exp ... +PASS: gdb.dwarf2/implptr-optimized-out.exp: p p->f +Running ./gdb.dwarf2/mac-fileno.exp ... +PASS: gdb.dwarf2/mac-fileno.exp: set listsize 1 +PASS: gdb.dwarf2/mac-fileno.exp: list func_cu1 +PASS: gdb.dwarf2/mac-fileno.exp: ptype func_cu1 +Running ./gdb.dwarf2/member-ptr-forwardref.exp ... +PASS: gdb.dwarf2/member-ptr-forwardref.exp: set cp-abi gnu-v3 +PASS: gdb.dwarf2/member-ptr-forwardref.exp: show cp-abi +PASS: gdb.dwarf2/member-ptr-forwardref.exp: ptype c +Running ./gdb.dwarf2/method-ptr.exp ... +PASS: gdb.dwarf2/method-ptr.exp: ptype the_typedef +Running ./gdb.dwarf2/pieces.exp ... +Running ./gdb.dwarf2/pr10770.exp ... +PASS: gdb.dwarf2/pr10770.exp: set breakpoint for pr10770 +PASS: gdb.dwarf2/pr10770.exp: cont +PASS: gdb.dwarf2/pr10770.exp: frame 2 +Running ./gdb.dwarf2/pr11465.exp ... +PASS: gdb.dwarf2/pr11465.exp: p N::c.C +Running ./gdb.dwarf2/pr13961.exp ... +PASS: gdb.dwarf2/pr13961.exp: break main +PASS: gdb.dwarf2/pr13961.exp: pr13961 +Running ./gdb.dwarf2/subrange.exp ... +PASS: gdb.dwarf2/subrange.exp: set language pascal +PASS: gdb.dwarf2/subrange.exp: ptype TByteArray +Running ./gdb.dwarf2/trace-crash.exp ... +PASS: gdb.dwarf2/trace-crash.exp: set tracepoint +PASS: gdb.dwarf2/trace-crash.exp: set tracepoint actions +Running ./gdb.dwarf2/typeddwarf.exp ... +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of j at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of l at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of m at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of n at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of o at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of p at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of q at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of r at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of s at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of t at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of u at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of v at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:29 +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of j at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of l at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of m at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of p at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of q at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of r at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of s at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of t at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of u at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of v at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: check value of z at typeddwarf.c:53 +PASS: gdb.dwarf2/typeddwarf.exp: set breakpoint at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: continue to breakpoint: continue to typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of w at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of x at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of y at typeddwarf.c:73 +PASS: gdb.dwarf2/typeddwarf.exp: check value of z at typeddwarf.c:73 +Running ./gdb.dwarf2/valop.exp ... +Running ./gdb.dwarf2/watch-notconst.exp ... +Running ./gdb.fortran/array-element.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/array-element.exp: array-element.exp +Running ./gdb.fortran/charset.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/charset.exp: charset.exp +Running ./gdb.fortran/common-block.exp ... +UNTESTED: gdb.fortran/common-block.exp: common-block.exp +Running ./gdb.fortran/complex.exp ... +UNTESTED: gdb.fortran/complex.exp: complex.exp +UNTESTED: gdb.fortran/complex.exp: Couldn't compile complex.f +Running ./gdb.fortran/derived-type.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/derived-type.exp: derived-type.exp +Running ./gdb.fortran/exprs.exp ... +PASS: gdb.fortran/exprs.exp: set print sevenbit-strings +PASS: gdb.fortran/exprs.exp: set language fortran +PASS: gdb.fortran/exprs.exp: set language to "fortran" +PASS: gdb.fortran/exprs.exp: Set value-history[1] using $1 +PASS: gdb.fortran/exprs.exp: Set value-history[2] using $2 +PASS: gdb.fortran/exprs.exp: Set value-history[3] using $3 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] using inplicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-1] again using implicit index $$ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using implicit index $ +PASS: gdb.fortran/exprs.exp: Print value-history[MAX-2] using explicit index $$2 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $0 +PASS: gdb.fortran/exprs.exp: Print value-history[MAX] using explicit index $$0 +PASS: gdb.fortran/exprs.exp: Print value-history[1] using explicit index $1 +PASS: gdb.fortran/exprs.exp: Print value-history[2] using explicit index $2 +PASS: gdb.fortran/exprs.exp: Print value-history[3] using explicit index $3 +PASS: gdb.fortran/exprs.exp: Print (value-history[MAX] - 3) using implicit index $ +PASS: gdb.fortran/exprs.exp: Use value-history element in arithmetic expression +PASS: gdb.fortran/exprs.exp: Set a new convenience variable +PASS: gdb.fortran/exprs.exp: Print contents of new convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable to a new value +PASS: gdb.fortran/exprs.exp: Print new contents of convenience variable +PASS: gdb.fortran/exprs.exp: Set convenience variable $_ +PASS: gdb.fortran/exprs.exp: Print contents of convenience variable $_ +PASS: gdb.fortran/exprs.exp: Use convenience variable in arithmetic expression +PASS: gdb.fortran/exprs.exp: Use convenience variable assignment in arithmetic expression +PASS: gdb.fortran/exprs.exp: Print contents of uninitialized convenience variable +PASS: gdb.fortran/exprs.exp: p 123 +PASS: gdb.fortran/exprs.exp: p -123 +PASS: gdb.fortran/exprs.exp: reject p _ +PASS: gdb.fortran/exprs.exp: p .TRUE. +PASS: gdb.fortran/exprs.exp: p .FALSE. +PASS: gdb.fortran/exprs.exp: p 'a' +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(2:4) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:3) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(5:) +PASS: gdb.fortran/exprs.exp: p 'abcdefg'(:) +PASS: gdb.fortran/exprs.exp: p .44 .LT. .45 +PASS: gdb.fortran/exprs.exp: p .44 .GT. .45 +PASS: gdb.fortran/exprs.exp: p 0.44 .LT. 0.45 +PASS: gdb.fortran/exprs.exp: p 0.44 .GT. 0.45 +PASS: gdb.fortran/exprs.exp: p 44. .LT. 45. +PASS: gdb.fortran/exprs.exp: p 44. .GT. 45. +PASS: gdb.fortran/exprs.exp: p 44.0 .LT. 45.0 +PASS: gdb.fortran/exprs.exp: p 44.0 .GT. 45.0 +PASS: gdb.fortran/exprs.exp: p 10D20 .LT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10D20 .GT. 10D21 +PASS: gdb.fortran/exprs.exp: p 10d20 .LT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10d20 .GT. 10d21 +PASS: gdb.fortran/exprs.exp: p 10E20 .LT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10E20 .GT. 10E21 +PASS: gdb.fortran/exprs.exp: p 10e20 .LT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10e20 .GT. 10e21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .LT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.D20 .GT. 10.D21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .LT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.d20 .GT. 10.d21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .LT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.E20 .GT. 10.E21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .LT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.e20 .GT. 10.e21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .LT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0D20 .GT. 10.0D21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .LT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0d20 .GT. 10.0d21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .LT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0E20 .GT. 10.0E21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .LT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0e20 .GT. 10.0e21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .LT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0D+20 .GT. 10.0D+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .LT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0d+20 .GT. 10.0d+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .LT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0E+20 .GT. 10.0E+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .LT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0e+20 .GT. 10.0e+21 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .LT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0D-11 .GT. 10.0D-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .LT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0d-11 .GT. 10.0d-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .LT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0E-11 .GT. 10.0E-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .LT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: p 10.0e-11 .GT. 10.0e-10 +PASS: gdb.fortran/exprs.exp: unary minus applied to int +PASS: gdb.fortran/exprs.exp: unary minus applied to real +PASS: gdb.fortran/exprs.exp: bool plus int +PASS: gdb.fortran/exprs.exp: int plus int +PASS: gdb.fortran/exprs.exp: real plus int +PASS: gdb.fortran/exprs.exp: real plus real +PASS: gdb.fortran/exprs.exp: bool minus int +PASS: gdb.fortran/exprs.exp: int minus int +PASS: gdb.fortran/exprs.exp: real minus int +PASS: gdb.fortran/exprs.exp: real minus real +PASS: gdb.fortran/exprs.exp: bool times int +PASS: gdb.fortran/exprs.exp: int times int +PASS: gdb.fortran/exprs.exp: real times int +PASS: gdb.fortran/exprs.exp: real times real +PASS: gdb.fortran/exprs.exp: bool divided by int +PASS: gdb.fortran/exprs.exp: int divided by int +PASS: gdb.fortran/exprs.exp: real divided by int +PASS: gdb.fortran/exprs.exp: real divided by real +PASS: gdb.fortran/exprs.exp: int powered by int +PASS: gdb.fortran/exprs.exp: combined exponentiation expression +PASS: gdb.fortran/exprs.exp: combined exponentiation expression in specified order +PASS: gdb.fortran/exprs.exp: int powered by real +PASS: gdb.fortran/exprs.exp: real powered by real +Running ./gdb.fortran/library-module.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/library-module.exp: Couldn't compile library-module-lib.f90 +Running ./gdb.fortran/logical.exp ... +UNTESTED: gdb.fortran/logical.exp: logical.exp +Running ./gdb.fortran/module.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/module.exp: module.exp +Running ./gdb.fortran/multi-dim.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/multi-dim.exp: multi-dim.exp +Running ./gdb.fortran/subarray.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gfortran. +UNTESTED: gdb.fortran/subarray.exp: subarray.exp +Running ./gdb.fortran/types.exp ... +PASS: gdb.fortran/types.exp: set print sevenbit-strings +PASS: gdb.fortran/types.exp: set language fortran +PASS: gdb.fortran/types.exp: set language to "fortran" +PASS: gdb.fortran/types.exp: pt 123 +PASS: gdb.fortran/types.exp: reject pt _ +PASS: gdb.fortran/types.exp: pt .TRUE. +PASS: gdb.fortran/types.exp: pt .FALSE. +PASS: gdb.fortran/types.exp: pt 'a' +PASS: gdb.fortran/types.exp: pt .44 +PASS: gdb.fortran/types.exp: pt 44.0 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10D20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10d20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10E20 +PASS: gdb.fortran/types.exp: pt 10e20 +PASS: gdb.fortran/types.exp: pt 10e20 +Running ./gdb.gdb/complaints.exp ... +Running ./gdb.gdb/observer.exp ... +Running ./gdb.gdb/selftest.exp ... +Running ./gdb.gdb/xfullpath.exp ... +Running ./gdb.go/basic-types.exp ... +PASS: gdb.go/basic-types.exp: set language go +PASS: gdb.go/basic-types.exp: set language to "go" +PASS: gdb.go/basic-types.exp: pt 123 +PASS: gdb.go/basic-types.exp: pt void(42) +PASS: gdb.go/basic-types.exp: pt byte(42) +PASS: gdb.go/basic-types.exp: pt int(42) +PASS: gdb.go/basic-types.exp: pt uint(42) +PASS: gdb.go/basic-types.exp: pt uintptr(42) +PASS: gdb.go/basic-types.exp: pt int8(42) +PASS: gdb.go/basic-types.exp: pt int16(42) +PASS: gdb.go/basic-types.exp: pt int32(42) +PASS: gdb.go/basic-types.exp: pt int64(42) +PASS: gdb.go/basic-types.exp: pt uint8(42) +PASS: gdb.go/basic-types.exp: pt uint16(42) +PASS: gdb.go/basic-types.exp: pt uint32(42) +PASS: gdb.go/basic-types.exp: pt uint64(42) +PASS: gdb.go/basic-types.exp: pt true +PASS: gdb.go/basic-types.exp: pt false +PASS: gdb.go/basic-types.exp: pt bool(0) +PASS: gdb.go/basic-types.exp: pt bool(1) +PASS: gdb.go/basic-types.exp: pt 'a' +PASS: gdb.go/basic-types.exp: pt "a simple string" +PASS: gdb.go/basic-types.exp: pt `a simple raw string` +PASS: gdb.go/basic-types.exp: pt .44 +PASS: gdb.go/basic-types.exp: pt 44.0 +PASS: gdb.go/basic-types.exp: pt 10e20 +PASS: gdb.go/basic-types.exp: pt 10E20 +PASS: gdb.go/basic-types.exp: pt float32(.42) +PASS: gdb.go/basic-types.exp: pt float64(.42) +PASS: gdb.go/basic-types.exp: pt complex64(.42) +XFAIL: gdb.go/basic-types.exp: pt complex64(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex64(i1.0) +PASS: gdb.go/basic-types.exp: pt complex128(.42) +XFAIL: gdb.go/basic-types.exp: pt complex128(.42i1.0) +XFAIL: gdb.go/basic-types.exp: pt complex128(i1.0) +Running ./gdb.go/chan.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/chan.exp: chan.exp +Running ./gdb.go/handcall.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/handcall.exp: handcall.exp +Running ./gdb.go/hello.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/hello.exp: hello.exp +Running ./gdb.go/integers.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/integers.exp: integers.exp +Running ./gdb.go/methods.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/methods.exp: methods.exp +Running ./gdb.go/package.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/package.exp: package +Running ./gdb.go/print.exp ... +PASS: gdb.go/print.exp: set language go +PASS: gdb.go/print.exp: set language to "go" +PASS: gdb.go/print.exp: check fp + text +PASS: gdb.go/print.exp: p 1. +PASS: gdb.go/print.exp: p 1.5 +PASS: gdb.go/print.exp: p 1.f +PASS: gdb.go/print.exp: p 1.5f +PASS: gdb.go/print.exp: p 1.l +PASS: gdb.go/print.exp: p 1.5l +PASS: gdb.go/print.exp: p 0x1.1 +PASS: gdb.go/print.exp: reject p 1.1x +PASS: gdb.go/print.exp: reject p 1.1ff +PASS: gdb.go/print.exp: reject p 1.1ll +Running ./gdb.go/strings.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/strings.exp: strings.exp +Running ./gdb.go/types.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/types.exp: types.exp +Running ./gdb.go/unsafe.exp ... +gdb compile failed, default_target_compile: Can't find x86_64-cros-linux-gnu-gccgo. +UNTESTED: gdb.go/unsafe.exp: unsafe.exp +Running ./gdb.java/jmain.exp ... +UNSUPPORTED: gdb.java/jmain.exp: compilation jmain.java +Running ./gdb.java/jmisc.exp ... +UNSUPPORTED: gdb.java/jmisc.exp: compilation jmisc.java +Running ./gdb.java/jnpe.exp ... +UNSUPPORTED: gdb.java/jnpe.exp: compilation jnpe.java +UNTESTED: gdb.java/jnpe.exp: Couldn't compile ./gdb.java/jnpe.java +Running ./gdb.java/jprint.exp ... +UNSUPPORTED: gdb.java/jprint.exp: compilation jprint.java +Running ./gdb.java/jv-exp.exp ... +PASS: gdb.java/jv-exp.exp: set print sevenbit-strings +PASS: gdb.java/jv-exp.exp: set width 0 +PASS: gdb.java/jv-exp.exp: set language java +PASS: gdb.java/jv-exp.exp: set language to "java" +PASS: gdb.java/jv-exp.exp: p 1 > 2 +PASS: gdb.java/jv-exp.exp: p 1 < 2 +Running ./gdb.java/jv-print.exp ... +PASS: gdb.java/jv-print.exp: print $pc +PASS: gdb.java/jv-print.exp: set print sevenbit-strings +PASS: gdb.java/jv-print.exp: set width 0 +PASS: gdb.java/jv-print.exp: set language java +PASS: gdb.java/jv-print.exp: set language to "java" +PASS: gdb.java/jv-print.exp: p 123 +PASS: gdb.java/jv-print.exp: p -123 +PASS: gdb.java/jv-print.exp: p/d 123 +PASS: gdb.java/jv-print.exp: p 0123 +PASS: gdb.java/jv-print.exp: p 00123 +PASS: gdb.java/jv-print.exp: p -0123 +PASS: gdb.java/jv-print.exp: p/o 0123 +PASS: gdb.java/jv-print.exp: p 0x123 +PASS: gdb.java/jv-print.exp: p -0x123 +PASS: gdb.java/jv-print.exp: p 0x0123 +PASS: gdb.java/jv-print.exp: p -0x0123 +PASS: gdb.java/jv-print.exp: p 0xABCDEF +PASS: gdb.java/jv-print.exp: p 0xabcdef +PASS: gdb.java/jv-print.exp: p 0xAbCdEf +PASS: gdb.java/jv-print.exp: p/x 0x123 +PASS: gdb.java/jv-print.exp: p 'a' +PASS: gdb.java/jv-print.exp: p/c 'a' +PASS: gdb.java/jv-print.exp: p/c 70 +PASS: gdb.java/jv-print.exp: p/x 'a' +PASS: gdb.java/jv-print.exp: p/d 'a' +PASS: gdb.java/jv-print.exp: p/t 'a' +PASS: gdb.java/jv-print.exp: p/x '\377' +PASS: gdb.java/jv-print.exp: p '\'' +PASS: gdb.java/jv-print.exp: p '\\' +PASS: gdb.java/jv-print.exp: reject p 0x +PASS: gdb.java/jv-print.exp: p '' +PASS: gdb.java/jv-print.exp: p ''' +PASS: gdb.java/jv-print.exp: reject p '\' +PASS: gdb.java/jv-print.exp: reject p '\\\' +PASS: gdb.java/jv-print.exp: reject p DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123DEADBEEF +PASS: gdb.java/jv-print.exp: reject p 123foobar.bazfoo3 +PASS: gdb.java/jv-print.exp: reject p 123EEEEEEEEEEEEEEEEE33333k333 +PASS: gdb.java/jv-print.exp: check for floating addition +PASS: gdb.java/jv-print.exp: reject p 09 +PASS: gdb.java/jv-print.exp: reject p 079 +PASS: gdb.java/jv-print.exp: reject p 0xG +PASS: gdb.java/jv-print.exp: reject p 0xAG +PASS: gdb.java/jv-print.exp: check fp + text +PASS: gdb.java/jv-print.exp: p 1. +PASS: gdb.java/jv-print.exp: p 1.5 +PASS: gdb.java/jv-print.exp: p 1.f +PASS: gdb.java/jv-print.exp: p 1.5f +PASS: gdb.java/jv-print.exp: p 1.d +PASS: gdb.java/jv-print.exp: p 1.5d +PASS: gdb.java/jv-print.exp: p 0x1.1 +PASS: gdb.java/jv-print.exp: reject p 1.1x +PASS: gdb.java/jv-print.exp: reject p 1.1ff +PASS: gdb.java/jv-print.exp: reject p 1.1dd +Running ./gdb.linespec/break-ask.exp ... +PASS: gdb.linespec/break-ask.exp: set multiple-symbols ask +PASS: gdb.linespec/break-ask.exp: set filename-display absolute +PASS: gdb.linespec/break-ask.exp: break twodup absolute +PASS: gdb.linespec/break-ask.exp: 0 +PASS: gdb.linespec/break-ask.exp: set filename-display relative +PASS: gdb.linespec/break-ask.exp: break twodup relative +PASS: gdb.linespec/break-ask.exp: 2 +PASS: gdb.linespec/break-ask.exp: expect breakpoint +PASS: gdb.linespec/break-ask.exp: info source +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere +PASS: gdb.linespec/break-ask.exp: break twodup relative other +PASS: gdb.linespec/break-ask.exp: 3 +PASS: gdb.linespec/break-ask.exp: expect breakpoint other +PASS: gdb.linespec/break-ask.exp: info source other +PASS: gdb.linespec/break-ask.exp: continue to breakpoint: body_elsewhere other +Running ./gdb.linespec/linespec.exp ... +PASS: gdb.linespec/linespec.exp: set multiple-symbols to all for linespec tests +PASS: gdb.linespec/linespec.exp: single-location break using dir/file:line +PASS: gdb.linespec/linespec.exp: clear breakpoint using dir/file:line +PASS: gdb.linespec/linespec.exp: multi-location break using file:line +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name +PASS: gdb.linespec/linespec.exp: multi-location break using duplicate function name and label +PASS: gdb.linespec/linespec.exp: complete condition +PASS: gdb.linespec/linespec.exp: disable pending breakpoints for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint on non-existent function +PASS: gdb.linespec/linespec.exp: set breakpoint at all instances of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at non-existent lspec.cc instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint at specific instance of NameSpace::overload +PASS: gdb.linespec/linespec.exp: set breakpoint in body.h +PASS: gdb.linespec/linespec.exp: set breakpoint in f1 +PASS: gdb.linespec/linespec.exp: add inferior for linespec tests +PASS: gdb.linespec/linespec.exp: switch to inferior 2 for linespec tests +PASS: gdb.linespec/linespec.exp: set the new inferior file for linespec tests +PASS: gdb.linespec/linespec.exp: set breakpoint at main in both inferiors +Running ./gdb.linespec/ls-dollar.exp ... +PASS: gdb.linespec/ls-dollar.exp: set listsize 1 +PASS: gdb.linespec/ls-dollar.exp: list $dollar_var +PASS: gdb.linespec/ls-dollar.exp: break $dollar_func +Running ./gdb.linespec/ls-errs.exp ... +PASS: gdb.linespec/ls-errs.exp: set breakpoint pending off +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break : +PASS: gdb.linespec/ls-errs.exp: break -100 +PASS: gdb.linespec/ls-errs.exp: break +500 +PASS: gdb.linespec/ls-errs.exp: break 1000 +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3: +PASS: gdb.linespec/ls-errs.exp: break +10: +PASS: gdb.linespec/ls-errs.exp: break -10: +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 : +PASS: gdb.linespec/ls-errs.exp: break +10 : +PASS: gdb.linespec/ls-errs.exp: break -10 : +PASS: gdb.linespec/ls-errs.exp: break 3 1 +PASS: gdb.linespec/ls-errs.exp: break +10 1 +PASS: gdb.linespec/ls-errs.exp: break -10 1 +PASS: gdb.linespec/ls-errs.exp: break 3 +1 +PASS: gdb.linespec/ls-errs.exp: break +10 +1 +PASS: gdb.linespec/ls-errs.exp: break -10 +1 +PASS: gdb.linespec/ls-errs.exp: break 3 +100 +PASS: gdb.linespec/ls-errs.exp: break +10 +100 +PASS: gdb.linespec/ls-errs.exp: break -10 +100 +PASS: gdb.linespec/ls-errs.exp: break 3 -10 +PASS: gdb.linespec/ls-errs.exp: break +10 -10 +PASS: gdb.linespec/ls-errs.exp: break -10 -10 +PASS: gdb.linespec/ls-errs.exp: break 3 foo +PASS: gdb.linespec/ls-errs.exp: break +10 foo +PASS: gdb.linespec/ls-errs.exp: break -10 foo +PASS: gdb.linespec/ls-errs.exp: break this_file_doesn't_exist.c:3 +PASS: gdb.linespec/ls-errs.exp: break this file has spaces.c:3 +PASS: gdb.linespec/ls-errs.exp: break "file::colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'file::colons.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this "file" has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'this "file" has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'this 'file' has quotes.c':3 +PASS: gdb.linespec/ls-errs.exp: break "this 'file' has quotes.c":3 +PASS: gdb.linespec/ls-errs.exp: break "spaces: and :colons.c":3 +PASS: gdb.linespec/ls-errs.exp: break 'more: :spaces: :and colons::.c':3 +PASS: gdb.linespec/ls-errs.exp: break "src-file.c':3 +PASS: gdb.linespec/ls-errs.exp: break 'src-file.c:3 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main:foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:main : +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:: +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 1 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 +100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 -100 +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:3 foo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:-100 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:-100" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:-100' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:+500 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:+500" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:+500' +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:1000 +PASS: gdb.linespec/ls-errs.exp: break "ls-errs.c:1000" +PASS: gdb.linespec/ls-errs.exp: break 'ls-errs.c:1000' +PASS: gdb.linespec/ls-errs.exp: break foobar +PASS: gdb.linespec/ls-errs.exp: break foo::bar +PASS: gdb.linespec/ls-errs.exp: break foo.bar +PASS: gdb.linespec/ls-errs.exp: break foo . +PASS: gdb.linespec/ls-errs.exp: break foo bar +PASS: gdb.linespec/ls-errs.exp: break foo 1 +PASS: gdb.linespec/ls-errs.exp: break foo 0 +PASS: gdb.linespec/ls-errs.exp: break foo +10 +PASS: gdb.linespec/ls-errs.exp: break foo -10 +PASS: gdb.linespec/ls-errs.exp: break foo +100 +PASS: gdb.linespec/ls-errs.exp: break foo -100 +PASS: gdb.linespec/ls-errs.exp: break main:there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main: there +PASS: gdb.linespec/ls-errs.exp: break main:here: +PASS: gdb.linespec/ls-errs.exp: break main :there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main : there +PASS: gdb.linespec/ls-errs.exp: break main:here : +PASS: gdb.linespec/ls-errs.exp: break main 3 +PASS: gdb.linespec/ls-errs.exp: break main +100 +PASS: gdb.linespec/ls-errs.exp: break main -100 +PASS: gdb.linespec/ls-errs.exp: break main foo +PASS: gdb.linespec/ls-errs.exp: break main:here 3 +PASS: gdb.linespec/ls-errs.exp: break main:here +100 +PASS: gdb.linespec/ls-errs.exp: break main:here -100 +PASS: gdb.linespec/ls-errs.exp: break main:here foo +PASS: gdb.linespec/ls-errs.exp: break if +PASS: gdb.linespec/ls-errs.exp: break task +PASS: gdb.linespec/ls-errs.exp: break thread +PASS: gdb.linespec/ls-errs.exp: break 'main.c'flubber +PASS: gdb.linespec/ls-errs.exp: break 'main.c',21 +PASS: gdb.linespec/ls-errs.exp: break 'main.c' +PASS: gdb.linespec/ls-errs.exp: break 'main.c'3 +PASS: gdb.linespec/ls-errs.exp: break 'main.c'+3 +PASS: gdb.linespec/ls-errs.exp: break $zippo +PASS: gdb.linespec/ls-errs.exp: break ls-errs.c:$zippo +Running ./gdb.linespec/macro-relative.exp ... +FAIL: gdb.linespec/macro-relative.exp: info macro HEADER +Running ./gdb.linespec/skip-two.exp ... +PASS: gdb.linespec/skip-two.exp: skip function dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored from main +PASS: gdb.linespec/skip-two.exp: continue to breakpoint: n +PASS: gdb.linespec/skip-two.exp: dupname ignored from n +PASS: gdb.linespec/skip-two.exp: skip delete 1 +PASS: gdb.linespec/skip-two.exp: skip file thefile.cc +PASS: gdb.linespec/skip-two.exp: step into dupname +PASS: gdb.linespec/skip-two.exp: finish from dupname +PASS: gdb.linespec/skip-two.exp: dupname ignored for thefile.cc +Running ./gdb.linespec/thread.exp ... +PASS: gdb.linespec/thread.exp: breakpoint line number in file +PASS: gdb.linespec/thread.exp: continue to breakpoint: 29 +PASS: gdb.linespec/thread.exp: setting breakpoint at thread +PASS: gdb.linespec/thread.exp: continue to breakpoint: thread function +Running ./gdb.mi/dw2-ref-missing-frame.exp ... +gdb compile failed, /usr/x86_64-pc-linux-gnu/x86_64-cros-linux-gnu/binutils-bin/2.22/ld.gold.real: internal error in output_address, at /var/tmp/portage/cross-x86_64-cros-linux-gnu/binutils-2.22-r20/work/binutils-2.22/gold/output.cc:3019 +collect2: error: ld returned 1 exit status +Running ./gdb.mi/gdb2549.exp ... +PASS: gdb.mi/gdb2549.exp: wrong arguments +PASS: gdb.mi/gdb2549.exp: no executable +PASS: gdb.mi/gdb2549.exp: breakpoint at main +PASS: gdb.mi/gdb2549.exp: mi runto main +PASS: gdb.mi/gdb2549.exp: register values x +PASS: gdb.mi/gdb2549.exp: register values f +PASS: gdb.mi/gdb2549.exp: register values d +PASS: gdb.mi/gdb2549.exp: register values o +PASS: gdb.mi/gdb2549.exp: register values t +Running ./gdb.mi/gdb669.exp ... +PASS: gdb.mi/gdb669.exp: successfully compiled posix threads test case +PASS: gdb.mi/gdb669.exp: breakpoint at main +PASS: gdb.mi/gdb669.exp: mi runto main +PASS: gdb.mi/gdb669.exp: -thread-list-ids (at main) +PASS: gdb.mi/gdb669.exp: info threads (at main) +PASS: gdb.mi/gdb669.exp: finding MI result string (at main) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (at main) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (at main) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (at main) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (at main) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (at main) +PASS: gdb.mi/gdb669.exp: next, try 0 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 0) +PASS: gdb.mi/gdb669.exp: info threads (try 0) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 0) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 0) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 0) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 0) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 0) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 0) +PASS: gdb.mi/gdb669.exp: next, try 1 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 1) +PASS: gdb.mi/gdb669.exp: info threads (try 1) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 1) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 1) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 1) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 1) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 1) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 1) +PASS: gdb.mi/gdb669.exp: next, try 2 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 2) +PASS: gdb.mi/gdb669.exp: info threads (try 2) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 2) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 2) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 2) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 2) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 2) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 2) +PASS: gdb.mi/gdb669.exp: next, try 3 +PASS: gdb.mi/gdb669.exp: -thread-list-ids (try 3) +PASS: gdb.mi/gdb669.exp: info threads (try 3) +PASS: gdb.mi/gdb669.exp: finding MI result string (try 3) +PASS: gdb.mi/gdb669.exp: finding number of threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: got number of threads from MI (try 3) +PASS: gdb.mi/gdb669.exp: console and MI have same number of threads (try 3) +PASS: gdb.mi/gdb669.exp: -thread_list_ids (try 3) +PASS: gdb.mi/gdb669.exp: finding threads in MI output (try 3) +PASS: gdb.mi/gdb669.exp: MI and console have same threads (try 3) +Running ./gdb.mi/gdb680.exp ... +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 0 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 1 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 2 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 3 +PASS: gdb.mi/gdb680.exp: -data-list-register-names -1, try 4 +Running ./gdb.mi/gdb701.exp ... +PASS: gdb.mi/gdb701.exp: breakpoint at main +PASS: gdb.mi/gdb701.exp: mi runto main +PASS: gdb.mi/gdb701.exp: step over "foo = 0" +PASS: gdb.mi/gdb701.exp: create fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr +PASS: gdb.mi/gdb701.exp: list children of fooPtr.x +PASS: gdb.mi/gdb701.exp: list children of fooPtr.y +PASS: gdb.mi/gdb701.exp: list children of fooPtr.z +Running ./gdb.mi/gdb792.exp ... +PASS: gdb.mi/gdb792.exp: breakpoint at main +PASS: gdb.mi/gdb792.exp: mi runto main +PASS: gdb.mi/gdb792.exp: create var for class A +PASS: gdb.mi/gdb792.exp: list children of class A +PASS: gdb.mi/gdb792.exp: list children of A.public +PASS: gdb.mi/gdb792.exp: list children of A.private +PASS: gdb.mi/gdb792.exp: list children of A.protected +PASS: gdb.mi/gdb792.exp: list children of A.protected.b +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.public +PASS: gdb.mi/gdb792.exp: list children of A.protected.b.private +PASS: gdb.mi/gdb792.exp: create var for class C which has baseclass A +PASS: gdb.mi/gdb792.exp: list children of class C +Running ./gdb.mi/mi2-amd64-entry-value.exp ... +PASS: gdb.mi/mi2-amd64-entry-value.exp: break different +PASS: gdb.mi/mi2-amd64-entry-value.exp: break breakhere_different +PASS: gdb.mi/mi2-amd64-entry-value.exp: break breakhere_validity +PASS: gdb.mi/mi2-amd64-entry-value.exp: break breakhere_invalid +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: set print entry-values +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: entry_equal: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: entry_equal: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: entry_different: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: entry_different: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: validity: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: no: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: only: set print entry-values +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: entry_equal: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: entry_equal: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: entry_different: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: only: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: only: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: only: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: preferred: set print entry-values +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: entry_equal: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: entry_equal: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: entry_different: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: preferred: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: preferred: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: preferred: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: set print entry-values +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: entry_equal: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: entry_equal: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: entry_different: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: if-needed: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: if-needed: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: if-needed: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: both: set print entry-values +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: entry_equal: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: entry_equal: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: entry_different: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: both: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: both: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: both: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: compact: set print entry-values +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: entry_equal: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: entry_equal: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: entry_different: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: compact: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: compact: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: compact: invalid: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: breakpoint at main +PASS: gdb.mi/mi2-amd64-entry-value.exp: mi runto main +PASS: gdb.mi/mi2-amd64-entry-value.exp: default: set print entry-values +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: entry_equal: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: entry_equal: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: entry_different: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: entry_different: -stack-list-variables +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: validity: stop (stopped at wrong place) +FAIL: gdb.mi/mi2-amd64-entry-value.exp: default: validity: -stack-list-variables +PASS: gdb.mi/mi2-amd64-entry-value.exp: default: invalid: stop +PASS: gdb.mi/mi2-amd64-entry-value.exp: default: invalid: -stack-list-variables +Running ./gdb.mi/mi2-prompt.exp ... +PASS: gdb.mi/mi2-prompt.exp: console set prompt +PASS: gdb.mi/mi2-prompt.exp: -break-list +PASS: gdb.mi/mi2-prompt.exp: set prompt (banana) +PASS: gdb.mi/mi2-prompt.exp: interpreter-exec mi -break-list +Running ./gdb.mi/mi2-var-child.exp ... +PASS: gdb.mi/mi2-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi2-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi2-var-child.exp: run to 237 (set breakpoint) +PASS: gdb.mi/mi2-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi2-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi2-var-child.exp: create local variable weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird +PASS: gdb.mi/mi2-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: is weird editable +PASS: gdb.mi/mi2-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi2-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi2-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi2-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi2-var-child.exp: delete var weird +PASS: gdb.mi/mi2-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi2-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi2-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi2-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi2-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi2-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi2-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi2-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi2-var-child.exp: break in do_anonymous_type_tests +PASS: gdb.mi/mi2-var-child.exp: continue to do_anonymous_type_tests breakpoint +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2 +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.a +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.c.*c +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.d +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.e +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.f +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.g +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.h.*h.**h +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.unsigned_integer +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.character +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.signed_character +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr +PASS: gdb.mi/mi2-var-child.exp: VT: list children of ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.char_ptr.*char_ptr +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.0 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.1 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.2 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.3 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.4 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.5 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.6 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.7 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.8 +PASS: gdb.mi/mi2-var-child.exp: path expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: expression for ptr2.*ptr.1_anonymous.2_anonymous.3_anonymous.simple.*simple.**simple.array_of_10.9 +PASS: gdb.mi/mi2-var-child.exp: VT: create root varobj for v +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3 +PASS: gdb.mi/mi2-var-child.exp: expression for v3 +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: expression for v3.x +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous +PASS: gdb.mi/mi2-var-child.exp: VT: list children of v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: expression for v3.1_anonymous.a +PASS: gdb.mi/mi2-var-child.exp: path expression for v3.2_anonymous.b +PASS: gdb.mi/mi2-var-child.exp: expression for v3.2_anonymous.b +Running ./gdb.mi/mi-async.exp ... +Running ./gdb.mi/mi-basics.exp ... +PASS: gdb.mi/mi-basics.exp: acceptance of MI operations +PASS: gdb.mi/mi-basics.exp: file-exec-and-symbols operation +PASS: gdb.mi/mi-basics.exp: file-exec-file operation +PASS: gdb.mi/mi-basics.exp: file-symbol-file operation +PASS: gdb.mi/mi-basics.exp: break-delete (all) operation +PASS: gdb.mi/mi-basics.exp: all breakpoints removed +PASS: gdb.mi/mi-basics.exp: environment-directory arg operation +PASS: gdb.mi/mi-basics.exp: environment-directory empty-string operation +PASS: gdb.mi/mi-basics.exp: environment-directory operation +PASS: gdb.mi/mi-basics.exp: environment-cd arg operation +PASS: gdb.mi/mi-basics.exp: environment-pwd operation +PASS: gdb.mi/mi-basics.exp: environment-path +PASS: gdb.mi/mi-basics.exp: environment-path no-args operation +PASS: gdb.mi/mi-basics.exp: environment-path dir1 dir2 operation +PASS: gdb.mi/mi-basics.exp: environment-path -r dir operation +PASS: gdb.mi/mi-basics.exp: environment-path -r operation +PASS: gdb.mi/mi-basics.exp: initial tty is mi_inferior_tty_name +PASS: gdb.mi/mi-basics.exp: set tty to /dev/pts/1 +PASS: gdb.mi/mi-basics.exp: tty was set correctly +PASS: gdb.mi/mi-basics.exp: set tty to the empty string +PASS: gdb.mi/mi-basics.exp: make sure tty is empty +PASS: gdb.mi/mi-basics.exp: set tty to mi_inferior_tty_name (the way it was) +PASS: gdb.mi/mi-basics.exp: verify tty is correct +Running ./gdb.mi/mi-break.exp ... +PASS: gdb.mi/mi-break.exp: break-insert -t operation +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-break.exp: insert temp breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-break.exp: list of breakpoints +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +KFAIL: gdb.mi/mi-break.exp: break-insert -r operation (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee2 (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp callee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: insert breakpoint with regexp .*llee (PRMS: mi/14270) +KFAIL: gdb.mi/mi-break.exp: list of breakpoints (PRMS: mi/14270) +PASS: gdb.mi/mi-break.exp: delete temp breakpoints +PASS: gdb.mi/mi-break.exp: insert breakpoint with ignore count at callme +PASS: gdb.mi/mi-break.exp: run to breakpoint with ignore count +PASS: gdb.mi/mi-break.exp: breakpoint at nonexistent function +PASS: gdb.mi/mi-break.exp: create varobj for function call +PASS: gdb.mi/mi-break.exp: update varobj for function call +PASS: gdb.mi/mi-break.exp: test disabled creation +PASS: gdb.mi/mi-break.exp: test disabled creation: cleanup +PASS: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-break.exp: breakpoint commands: set commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are set +PASS: gdb.mi/mi-break.exp: breakpoint commands: clear commands +PASS: gdb.mi/mi-break.exp: breakpoint commands: check that commands are cleared +ERROR: couldn't load /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/gdb.mi/mi-break into /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb (timed out). +UNRESOLVED: gdb.mi/mi-break.exp: breakpoint at main +FAIL: gdb.mi/mi-break.exp: mi runto main (unknown output after running) +FAIL: gdb.mi/mi-break.exp: breakpoint commands: insert breakpoint at basics.c:callee2, again +FAIL: gdb.mi/mi-break.exp: breakpoint commands: set commands +FAIL: gdb.mi/mi-break.exp: breakpoint commands: continue (MI error) +FAIL: gdb.mi/mi-break.exp: intermediate stop and continue +FAIL: gdb.mi/mi-break.exp: test hitting breakpoint with commands (unknown output after running) +PASS: gdb.mi/mi-break.exp: create local variable tpnum +PASS: gdb.mi/mi-break.exp: eval tpnum before tracepoint +FAIL: gdb.mi/mi-break.exp: break-insert -a operation +PASS: gdb.mi/mi-break.exp: update tpnum +FAIL: gdb.mi/mi-break.exp: eval tpnum after tracepoint +Running ./gdb.mi/mi-breakpoint-changed.exp ... +PASS: gdb.mi/mi-breakpoint-changed.exp: breakpoint at main +FAIL: gdb.mi/mi-breakpoint-changed.exp: mi runto main (unknown output after running) +PASS: gdb.mi/mi-breakpoint-changed.exp: change command +PASS: gdb.mi/mi-breakpoint-changed.exp: watch watch +PASS: gdb.mi/mi-breakpoint-changed.exp: trace marker +PASS: gdb.mi/mi-breakpoint-changed.exp: catch syscall +PASS: gdb.mi/mi-breakpoint-changed.exp: dprintf marker, "arg" " +PASS: gdb.mi/mi-breakpoint-changed.exp: condition 2 main > 0x0 +PASS: gdb.mi/mi-breakpoint-changed.exp: disable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: enable 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: ignore 5 1 +PASS: gdb.mi/mi-breakpoint-changed.exp: passcount 1 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 3 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 4 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 5 +PASS: gdb.mi/mi-breakpoint-changed.exp: delete 6 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc1 resolved +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc1 resolved: hit_count is updated +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to pendfunc1 breakpoint +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: delete breakpoint on pendfunc1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on marker +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: insert breakpoint on pendfunc3 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 1 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 resolved +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: continue to marker 2 +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: breakpoint on pendfunc3 pending again +PASS: gdb.mi/mi-breakpoint-changed.exp: pending resolved: +Running ./gdb.mi/mi-catch-load.exp ... +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-load: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-load: catch load +FAIL: gdb.mi/mi-catch-load.exp: catch-load: solib-event stop +PASS: gdb.mi/mi-catch-load.exp: breakpoint at main +PASS: gdb.mi/mi-catch-load.exp: mi runto main +PASS: gdb.mi/mi-catch-load.exp: catch-unload: auto-solib-add on +PASS: gdb.mi/mi-catch-load.exp: catch-unload: catch unload +FAIL: gdb.mi/mi-catch-load.exp: catch-unload: solib-event stop +Running ./gdb.mi/mi-cli.exp ... +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with no arguments +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with one argument +PASS: gdb.mi/mi-cli.exp: -interpreter-exec with bogus interpreter +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console bogus +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "file $binfile" +PASS: gdb.mi/mi-cli.exp: breakpoint at main +PASS: gdb.mi/mi-cli.exp: mi runto main +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set args foobar" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "show args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "break callee4" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "info break" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set listsize 1" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" +PASS: gdb.mi/mi-cli.exp: continue to callee4 +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "delete 2" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "up" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "down" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "frame 2" +PASS: gdb.mi/mi-cli.exp: -stack-select-frame 0 +PASS: gdb.mi/mi-cli.exp: check *stopped from CLI command +PASS: gdb.mi/mi-cli.exp: -break-insert -t basics.c:$line_main_hello +PASS: gdb.mi/mi-cli.exp: -exec-continue to line $line_main_hello +PASS: gdb.mi/mi-cli.exp: 34 next: run +PASS: gdb.mi/mi-cli.exp: 34 next: stop +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "list" at basics.c:$line_main_return +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "help set args" +PASS: gdb.mi/mi-cli.exp: -interpreter-exec console "set $pc=0x0" +Running ./gdb.mi/mi-cmd-param-changed.exp ... +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: breakpoint at main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: mi runto main +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: interpreter-exec "set scheduler-locking step" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking on" no event (requested by MI) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking step" no event (requested by MI interp) +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set scheduler-locking stepr" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remotecache" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" warmup +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set check type" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set trace-notes bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file foo" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set remote exec-file bar" no event +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile on" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "maint set profile off" +PASS: gdb.mi/mi-cmd-param-changed.exp: cmd param: "set ch type on" +Running ./gdb.mi/mi-console.exp ... +PASS: gdb.mi/mi-console.exp: breakpoint at main +PASS: gdb.mi/mi-console.exp: mi runto main +PASS: gdb.mi/mi-console.exp: Testing console output +UNSUPPORTED: gdb.mi/mi-console.exp: Testing console output inferior output +PASS: gdb.mi/mi-console.exp: finished step over hello +Running ./gdb.mi/mi-disassemble.exp ... +PASS: gdb.mi/mi-disassemble.exp: breakpoint at main +PASS: gdb.mi/mi-disassemble.exp: mi runto main +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble from pc to pc+12 assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file & line, assembly with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble range assembly mixed with opcodes +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus filename +PASS: gdb.mi/mi-disassemble.exp: data-disassemble bogus address +PASS: gdb.mi/mi-disassemble.exp: data-disassemble mix different args +PASS: gdb.mi/mi-disassemble.exp: data-disassemble wrong mode arg +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly only +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (zero lines) assembly mixed +PASS: gdb.mi/mi-disassemble.exp: data-disassemble file, line, number (more than main lines) assembly mixed +Running ./gdb.mi/mi-eval.exp ... +PASS: gdb.mi/mi-eval.exp: breakpoint at callee4 +PASS: gdb.mi/mi-eval.exp: mi runto callee4 +PASS: gdb.mi/mi-eval.exp: next at callee4 +PASS: gdb.mi/mi-eval.exp: eval A +PASS: gdb.mi/mi-eval.exp: eval &A +PASS: gdb.mi/mi-eval.exp: eval A+3 +PASS: gdb.mi/mi-eval.exp: eval A + 3 +Running ./gdb.mi/mi-file.exp ... +PASS: gdb.mi/mi-file.exp: request path info of current source file (basics.c) +PASS: gdb.mi/mi-file.exp: Getting a list of source files. +Running ./gdb.mi/mi-file-transfer.exp ... +FAIL: gdb.mi/mi-file-transfer.exp: put binary file +FAIL: gdb.mi/mi-file-transfer.exp: get binary file +FAIL: gdb.mi/mi-file-transfer.exp: compare binary file +FAIL: gdb.mi/mi-file-transfer.exp: deleted binary file +Running ./gdb.mi/mi-fill-memory.exp ... +PASS: gdb.mi/mi-fill-memory.exp: breakpoint at main +PASS: gdb.mi/mi-fill-memory.exp: mi runto main +PASS: gdb.mi/mi-fill-memory.exp: next at main +PASS: gdb.mi/mi-fill-memory.exp: no arguments +PASS: gdb.mi/mi-fill-memory.exp: one argument missing +PASS: gdb.mi/mi-fill-memory.exp: memory successfully written +PASS: gdb.mi/mi-fill-memory.exp: memory successfully filled (8 bytes) +PASS: gdb.mi/mi-fill-memory.exp: pattern correctly read from memory +Running ./gdb.mi/mi-fullname-deleted.exp ... +PASS: gdb.mi/mi-fullname-deleted.exp: set substitute-path +PASS: gdb.mi/mi-fullname-deleted.exp: fullname present +PASS: gdb.mi/mi-fullname-deleted.exp: substituted fullname +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does not match +PASS: gdb.mi/mi-fullname-deleted.exp: compare_filenames_for_search does match +Running ./gdb.mi/mi-hack-cli.exp ... +PASS: gdb.mi/mi-hack-cli.exp: show architecture +PASS: gdb.mi/mi-hack-cli.exp: 47show architecture +Running ./gdb.mi/mi-info-os.exp ... +FAIL: gdb.mi/mi-info-os.exp: -info-os +Running ./gdb.mi/mi-inheritance-syntax-error.exp ... +PASS: gdb.mi/mi-inheritance-syntax-error.exp: breakpoint at C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: mi runto C::testLocation +PASS: gdb.mi/mi-inheritance-syntax-error.exp: create var for THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: list children of THIS +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -var-info-path-expression var1.A +PASS: gdb.mi/mi-inheritance-syntax-error.exp: -data-evaluate-expression (*(class A*) this) +Running ./gdb.mi/mi-logging.exp ... +PASS: gdb.mi/mi-logging.exp: breakpoint at main +PASS: gdb.mi/mi-logging.exp: mi runto main +PASS: gdb.mi/mi-logging.exp: logging on +PASS: gdb.mi/mi-logging.exp: logged step +PASS: gdb.mi/mi-logging.exp: logged next +PASS: gdb.mi/mi-logging.exp: logging off +PASS: gdb.mi/mi-logging.exp: Log file contents +PASS: gdb.mi/mi-logging.exp: redirect logging on +PASS: gdb.mi/mi-logging.exp: redirect logging off +PASS: gdb.mi/mi-logging.exp: Redirect log file contents +Running ./gdb.mi/mi-memory-changed.exp ... +PASS: gdb.mi/mi-memory-changed.exp: insert breakpoint +PASS: gdb.mi/mi-memory-changed.exp: continue to callee4 +PASS: gdb.mi/mi-memory-changed.exp: set var C = 4 +PASS: gdb.mi/mi-memory-changed.exp: create objvar for C +PASS: gdb.mi/mi-memory-changed.exp: change C thru. varobj +PASS: gdb.mi/mi-memory-changed.exp: change C thru. -data-write-memory-bytes +PASS: gdb.mi/mi-memory-changed.exp: get address of main +Running ./gdb.mi/mi-nonstop-exit.exp ... +PASS: gdb.mi/mi-nonstop-exit.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue +PASS: gdb.mi/mi-nonstop-exit.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop-exit.exp: mi runto main +PASS: gdb.mi/mi-nonstop-exit.exp: finished exec continue (2) +Running ./gdb.mi/mi-nonstop.exp ... +PASS: gdb.mi/mi-nonstop.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nonstop.exp: breakpoint at main +PASS: gdb.mi/mi-nonstop.exp: mi runto main +PASS: gdb.mi/mi-nonstop.exp: breakpoint at marker +PASS: gdb.mi/mi-nonstop.exp: w0,i0 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i0 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 1 +PASS: gdb.mi/mi-nonstop.exp: select thread 2 +PASS: gdb.mi/mi-nonstop.exp: create varobj in first thread +PASS: gdb.mi/mi-nonstop.exp: select thread 3 +PASS: gdb.mi/mi-nonstop.exp: create varobj in second thread +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 2 +PASS: gdb.mi/mi-nonstop.exp: thread state, resume 2 +PASS: gdb.mi/mi-nonstop.exp: w1,i1 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 3 +PASS: gdb.mi/mi-nonstop.exp: update varobj, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w0, 1 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: interrupted +PASS: gdb.mi/mi-nonstop.exp: got interrupt +PASS: gdb.mi/mi-nonstop.exp: thread state, stop 4 +PASS: gdb.mi/mi-nonstop.exp: resume all +PASS: gdb.mi/mi-nonstop.exp: w0,i2 stop +PASS: gdb.mi/mi-nonstop.exp: w1,i2 stop +PASS: gdb.mi/mi-nonstop.exp: set condition, 1 +PASS: gdb.mi/mi-nonstop.exp: w0,i3 stop +PASS: gdb.mi/mi-nonstop.exp: thread state, stop on cond breakpoint +PASS: gdb.mi/mi-nonstop.exp: update varobj, 2 +PASS: gdb.mi/mi-nonstop.exp: check varobj, w1, 1 +PASS: gdb.mi/mi-nonstop.exp: stacktrace of running thread +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +PASS: gdb.mi/mi-nonstop.exp: select first worker thread +PASS: gdb.mi/mi-nonstop.exp: ask the second thread to exit +UNSUPPORTED: gdb.mi/mi-nonstop.exp: wait for thread exit +PASS: gdb.mi/mi-nonstop.exp: stacktrace of stopped thread +Running ./gdb.mi/mi-nsintrall.exp ... +PASS: gdb.mi/mi-nsintrall.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at main +PASS: gdb.mi/mi-nsintrall.exp: mi runto main +PASS: gdb.mi/mi-nsintrall.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsintrall.exp: stop 0 +PASS: gdb.mi/mi-nsintrall.exp: stop 1 +PASS: gdb.mi/mi-nsintrall.exp: stop 2 +PASS: gdb.mi/mi-nsintrall.exp: stop 3 +PASS: gdb.mi/mi-nsintrall.exp: stop 4 +PASS: gdb.mi/mi-nsintrall.exp: stop 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all stopped +PASS: gdb.mi/mi-nsintrall.exp: resume all, no breakpoint +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all +PASS: gdb.mi/mi-nsintrall.exp: interrupt all threads +PASS: gdb.mi/mi-nsintrall.exp: interrupt 0 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 1 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 2 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 3 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 4 +PASS: gdb.mi/mi-nsintrall.exp: interrupt 5 +PASS: gdb.mi/mi-nsintrall.exp: thread state, all interrupted +PASS: gdb.mi/mi-nsintrall.exp: resume all after interrupting +PASS: gdb.mi/mi-nsintrall.exp: thread state, resume all after interrupting +Running ./gdb.mi/mi-nsmoribund.exp ... +PASS: gdb.mi/mi-nsmoribund.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at main +PASS: gdb.mi/mi-nsmoribund.exp: mi runto main +PASS: gdb.mi/mi-nsmoribund.exp: breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: stop 0 +PASS: gdb.mi/mi-nsmoribund.exp: stop 1 +PASS: gdb.mi/mi-nsmoribund.exp: stop 2 +PASS: gdb.mi/mi-nsmoribund.exp: stop 3 +PASS: gdb.mi/mi-nsmoribund.exp: stop 4 +PASS: gdb.mi/mi-nsmoribund.exp: stop 5 +PASS: gdb.mi/mi-nsmoribund.exp: stop 6 +PASS: gdb.mi/mi-nsmoribund.exp: stop 7 +PASS: gdb.mi/mi-nsmoribund.exp: stop 8 +PASS: gdb.mi/mi-nsmoribund.exp: stop 9 +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all stopped except the main thread +PASS: gdb.mi/mi-nsmoribund.exp: select thread 5 +PASS: gdb.mi/mi-nsmoribund.exp: thread specific breakpoint at thread_function +PASS: gdb.mi/mi-nsmoribund.exp: resume all, thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: hit thread specific breakpoint +PASS: gdb.mi/mi-nsmoribund.exp: thread state: all running except the breakpoint thread +PASS: gdb.mi/mi-nsmoribund.exp: resume all, program exited normally +Running ./gdb.mi/mi-ns-stale-regcache.exp ... +PASS: gdb.mi/mi-ns-stale-regcache.exp: breakpoint at main +PASS: gdb.mi/mi-ns-stale-regcache.exp: mi runto main +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale register cache of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: no stale frame info of resumed thread +PASS: gdb.mi/mi-ns-stale-regcache.exp: main thread still running +Running ./gdb.mi/mi-nsthrexec.exp ... +Running ./gdb.mi/mi-pending.exp ... +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on pendfunc1 +PASS: gdb.mi/mi-pending.exp: MI pending breakpoint on mi-pendshr.c:pendfunc2 if x==4 +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc1 a second time +PASS: gdb.mi/mi-pending.exp: Run till MI pending breakpoint on pendfunc2 with x==4 +Running ./gdb.mi/mi-pthreads.exp ... +PASS: gdb.mi/mi-pthreads.exp: successfully compiled posix threads test case +PASS: gdb.mi/mi-pthreads.exp: breakpoint at done_making_threads +PASS: gdb.mi/mi-pthreads.exp: mi runto done_making_threads +PASS: gdb.mi/mi-pthreads.exp: -thread_list_ids (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: finding threads in MI output (in check_mi_thread_command_set) +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 123456789 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 6 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 5 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 4 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 3 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 2 +PASS: gdb.mi/mi-pthreads.exp: check_mi_thread_command_set: -thread-select 1 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 6 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 5 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 4 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 3 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 2 +PASS: gdb.mi/mi-pthreads.exp: check =thread-selected: thread 1 +Running ./gdb.mi/mi-read-memory.exp ... +PASS: gdb.mi/mi-read-memory.exp: breakpoint at main +PASS: gdb.mi/mi-read-memory.exp: mi runto main +PASS: gdb.mi/mi-read-memory.exp: next at main +PASS: gdb.mi/mi-read-memory.exp: no arguments +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte +PASS: gdb.mi/mi-read-memory.exp: 3x2, one byte offset by -6 +PASS: gdb.mi/mi-read-memory.exp: expression in quotes +PASS: gdb.mi/mi-read-memory.exp: ascii and data +PASS: gdb.mi/mi-read-memory.exp: decimal +PASS: gdb.mi/mi-read-memory.exp: octal +Running ./gdb.mi/mi-record-changed.exp ... +Running ./gdb.mi/mi-regs.exp ... +Running ./gdb.mi/mi-return.exp ... +PASS: gdb.mi/mi-return.exp: breakpoint at callee4 +PASS: gdb.mi/mi-return.exp: mi runto callee4 +PASS: gdb.mi/mi-return.exp: delete all breakpoints +PASS: gdb.mi/mi-return.exp: return from callee4 now +Running ./gdb.mi/mi-reverse.exp ... +Running ./gdb.mi/mi-simplerun.exp ... +PASS: gdb.mi/mi-simplerun.exp: break-insert operation +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:callee2 +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at basics.c:$line_callee3_head +PASS: gdb.mi/mi-simplerun.exp: insert breakpoint at "<fullfilename>":$line_callee4_head +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints +PASS: gdb.mi/mi-simplerun.exp: disabling of breakpoints +PASS: gdb.mi/mi-simplerun.exp: list of breakpoints, 16 disabled +PASS: gdb.mi/mi-simplerun.exp: run to main +PASS: gdb.mi/mi-simplerun.exp: next at main +PASS: gdb.mi/mi-simplerun.exp: step at main +PASS: gdb.mi/mi-simplerun.exp: step to callee4 +PASS: gdb.mi/mi-simplerun.exp: exec-finish +PASS: gdb.mi/mi-simplerun.exp: continue to end +Running ./gdb.mi/mi-solib.exp ... +PASS: gdb.mi/mi-solib.exp: set stop-on-solib-events +PASS: gdb.mi/mi-solib.exp: check for solib event +Running ./gdb.mi/mi-stack.exp ... +PASS: gdb.mi/mi-stack.exp: breakpoint at callee4 +PASS: gdb.mi/mi-stack.exp: mi runto callee4 +PASS: gdb.mi/mi-stack.exp: stack frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 1 +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 3 +PASS: gdb.mi/mi-stack.exp: stack frame listing wrong +PASS: gdb.mi/mi-stack.exp: selected frame listing +PASS: gdb.mi/mi-stack.exp: stack frame listing 1 300 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 0 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 1 +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 3 +PASS: gdb.mi/mi-stack.exp: stack args listing wrong +PASS: gdb.mi/mi-stack.exp: stack args listing 1 1 300 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names +PASS: gdb.mi/mi-stack.exp: next's in callee4 +PASS: gdb.mi/mi-stack.exp: stack locals listing of names and values +PASS: gdb.mi/mi-stack.exp: stack locals listing, simple types: names and values, complex type: names and types +PASS: gdb.mi/mi-stack.exp: stack locals listing wrong +PASS: gdb.mi/mi-stack.exp: stack select frame 1 +PASS: gdb.mi/mi-stack.exp: stack locals listing for new frame +PASS: gdb.mi/mi-stack.exp: stack locals for same frame (level 1) +PASS: gdb.mi/mi-stack.exp: stack info-depth +PASS: gdb.mi/mi-stack.exp: stack info-depth 3 +PASS: gdb.mi/mi-stack.exp: stack info-depth 99 +PASS: gdb.mi/mi-stack.exp: stack info-depth wrong usage +Running ./gdb.mi/mi-stepi.exp ... +PASS: gdb.mi/mi-stepi.exp: breakpoint at main +PASS: gdb.mi/mi-stepi.exp: mi runto main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main +PASS: gdb.mi/mi-stepi.exp: step-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main +PASS: gdb.mi/mi-stepi.exp: next-instruction at main (line check) +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 +PASS: gdb.mi/mi-stepi.exp: next-instruction at main 2 (line check) +Running ./gdb.mi/mi-stepn.exp ... +PASS: gdb.mi/mi-stepn.exp: breakpoint at main +PASS: gdb.mi/mi-stepn.exp: mi runto main +PASS: gdb.mi/mi-stepn.exp: breakpoint at do_nothing +PASS: gdb.mi/mi-stepn.exp: breakpoint-hit reported +Running ./gdb.mi/mi-syn-frame.exp ... +PASS: gdb.mi/mi-syn-frame.exp: breakpoint at main +PASS: gdb.mi/mi-syn-frame.exp: mi runto main +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint foo +PASS: gdb.mi/mi-syn-frame.exp: call inferior's function with a breakpoint set in it +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function stopped at bp, showing gdb dummy frame +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: insert breakpoint subroutine +PASS: gdb.mi/mi-syn-frame.exp: data evaluate expression +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: finished exec continue +PASS: gdb.mi/mi-syn-frame.exp: list stack frames +PASS: gdb.mi/mi-syn-frame.exp: call inferior function which raises exception +PASS: gdb.mi/mi-syn-frame.exp: backtrace from inferior function at exception +Running ./gdb.mi/mi-until.exp ... +PASS: gdb.mi/mi-until.exp: break-insert operation +PASS: gdb.mi/mi-until.exp: run to main +PASS: gdb.mi/mi-until.exp: break-delete 1 +KFAIL: gdb.mi/mi-until.exp: until after while loop (stopped at wrong place) (PRMS: gdb/2104) +PASS: gdb.mi/mi-until.exp: until line number +PASS: gdb.mi/mi-until.exp: until line number:file +PASS: gdb.mi/mi-until.exp: until after current function +Running ./gdb.mi/mi-var-block.exp ... +PASS: gdb.mi/mi-var-block.exp: breakpoint at do_block_tests +PASS: gdb.mi/mi-var-block.exp: mi runto do_block_tests +PASS: gdb.mi/mi-var-block.exp: create local variable cb +PASS: gdb.mi/mi-var-block.exp: try to create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 1 +PASS: gdb.mi/mi-var-block.exp: delete var foo 1 +PASS: gdb.mi/mi-var-block.exp: create local variable foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 2 +PASS: gdb.mi/mi-var-block.exp: update all vars: cb foo changed +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 3 +PASS: gdb.mi/mi-var-block.exp: create local variable inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 4 +PASS: gdb.mi/mi-var-block.exp: create local variable foo2 +XFAIL: gdb.mi/mi-var-block.exp: update inner_foo: should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: evaluate inner_foo: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update foo: did not change +PASS: gdb.mi/mi-var-block.exp: delete var inner_foo +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 5 +XFAIL: gdb.mi/mi-var-block.exp: update foo2: should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: step at do_block_test 6 +XFAIL: gdb.mi/mi-var-block.exp: update foo2 should be out of scope: KNOWN PROBLEM +XFAIL: gdb.mi/mi-var-block.exp: update foo should be out of scope: KNOWN PROBLEM +PASS: gdb.mi/mi-var-block.exp: update cb +PASS: gdb.mi/mi-var-block.exp: delete var foo 2 +PASS: gdb.mi/mi-var-block.exp: delete var foo2 +PASS: gdb.mi/mi-var-block.exp: delete var cb +Running ./gdb.mi/mi-var-child.exp ... +PASS: gdb.mi/mi-var-child.exp: breakpoint at do_children_tests +PASS: gdb.mi/mi-var-child.exp: mi runto do_children_tests +PASS: gdb.mi/mi-var-child.exp: run to 215 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create local variable struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.character +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_int +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_struct +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.func_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.3 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.4 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.5 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.6 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.7 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.8 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.long_array.9 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.a +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.b +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.c +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.u1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.g +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.h +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.i +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.f +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2 +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.d +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.e +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s1.foo +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.array_ptr +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.s2.u2.u1s2.func +PASS: gdb.mi/mi-var-child.exp: get children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of struct_declarations.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step to line $line_dct_123 +PASS: gdb.mi/mi-var-child.exp: create local variable weird +PASS: gdb.mi/mi-var-child.exp: get children of weird +PASS: gdb.mi/mi-var-child.exp: get number of children of weird +PASS: gdb.mi/mi-var-child.exp: get children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.long_array +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird.int_ptr_ptr.*int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of weird->int_ptr_ptr.*weird->int_ptr_ptr.**weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: is weird editable +PASS: gdb.mi/mi-var-child.exp: is weird->int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr editable +PASS: gdb.mi/mi-var-child.exp: is weird.u1 editable +PASS: gdb.mi/mi-var-child.exp: is weird.s2 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.a editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.b editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.u1.c editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations.long_array.0 editable +PASS: gdb.mi/mi-var-child.exp: is struct_declarations editable +PASS: gdb.mi/mi-var-child.exp: delete var weird +PASS: gdb.mi/mi-var-child.exp: update all vars. None changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.integer +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.char_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars int_ptr_ptr and children changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 6 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.0 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.1 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_123 + 8 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.2 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.3-9 changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 1 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.func_ptr changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_nothing + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.10 changed, don't print values. +PASS: gdb.mi/mi-var-child.exp: step $line_dct_a0_0 +PASS: gdb.mi/mi-var-child.exp: update all vars struct_declarations.long_array.11 changed, print values. +PASS: gdb.mi/mi-var-child.exp: listing of names and values of children +PASS: gdb.mi/mi-var-child.exp: listing of children, simple types: names, type and values, complex types: names and types +PASS: gdb.mi/mi-var-child.exp: delete var struct_declarations +PASS: gdb.mi/mi-var-child.exp: delete var weird->int_ptr_ptr +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 1 +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->char_ptr.*psnp->char_ptr.**psnp->char_ptr.***psnp->char_ptr.****psnp->char_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->long_ptr.*psnp->long_ptr.**psnp->long_ptr.***psnp->long_ptr.****psnp->long_ptr +PASS: gdb.mi/mi-var-child.exp: create local variable psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0 +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get number of children of psnp->ptrs.0.next.char_ptr.*char_ptr.**char_ptr.***char_ptr +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next +PASS: gdb.mi/mi-var-child.exp: get children of psnp->ptrs.0.next.next.ptrs +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 2 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->char_ptr (and 0.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 3 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->char_ptr (and 1.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 4 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->char_ptr (and 2.char_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 5 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->long_ptr (and 0.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 6 +XFAIL: gdb.mi/mi-var-child.exp: update all vars psnp->next->long_ptr (and 1.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: step $line_dct_snp0 + 7 +PASS: gdb.mi/mi-var-child.exp: update all vars psnp->next->next->long_ptr (and 2.long_ptr) changed +PASS: gdb.mi/mi-var-child.exp: run to mi-var-child.c:323 (set breakpoint) +PASS: gdb.mi/mi-var-child.exp: create varobj for s +PASS: gdb.mi/mi-var-child.exp: list children of S +PASS: gdb.mi/mi-var-child.exp: delete S.a +PASS: gdb.mi/mi-var-child.exp: delete S.b +PASS: gdb.mi/mi-var-child.exp: delete S +Running ./gdb.mi/mi-var-child-f.exp ... +UNSUPPORTED: gdb.mi/mi-var-child-f.exp: compilation array.f +Running ./gdb.mi/mi-var-cmd.exp ... +PASS: gdb.mi/mi-var-cmd.exp: create global variable +PASS: gdb.mi/mi-var-cmd.exp: create non-existent variable +PASS: gdb.mi/mi-var-cmd.exp: create out of scope variable +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: run to 148 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create local variable linteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpinteger +PASS: gdb.mi/mi-var-cmd.exp: create local variable lcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: create local variable llong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lplong +PASS: gdb.mi/mi-var-cmd.exp: create local variable lfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpfloat +PASS: gdb.mi/mi-var-cmd.exp: create local variable ldouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpdouble +PASS: gdb.mi/mi-var-cmd.exp: create local variable lsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable lpsimple +PASS: gdb.mi/mi-var-cmd.exp: create local variable func +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: create lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: create lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: create int +PASS: gdb.mi/mi-var-cmd.exp: update all vars +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_test +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (2) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (3) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (4) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpcharacter changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (5) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: many changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (6) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: func and lpsimple changed +PASS: gdb.mi/mi-var-cmd.exp: step at do_locals_tests (7) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lsimple and others changed +PASS: gdb.mi/mi-var-cmd.exp: assign to global_simple +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger again, same value +PASS: gdb.mi/mi-var-cmd.exp: update all vars: linteger not changed after same assign +PASS: gdb.mi/mi-var-cmd.exp: eval linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: update all vars: lpinteger changed after assign +PASS: gdb.mi/mi-var-cmd.exp: update all vars: no changes on second update +PASS: gdb.mi/mi-var-cmd.exp: eval lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to linteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lpinteger +PASS: gdb.mi/mi-var-cmd.exp: assign to lcharacter +PASS: gdb.mi/mi-var-cmd.exp: eval lcharacter +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: eval llong +PASS: gdb.mi/mi-var-cmd.exp: assign to llong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: eval lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lplong +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: eval lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to lpfloat +PASS: gdb.mi/mi-var-cmd.exp: assign to ldouble +PASS: gdb.mi/mi-var-cmd.exp: assign to func +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: assign to lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: var update +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func +PASS: gdb.mi/mi-var-cmd.exp: assign same value to func (update) +PASS: gdb.mi/mi-var-cmd.exp: create global variable array_ptr +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer +PASS: gdb.mi/mi-var-cmd.exp: assign same array to pointer (update) +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: mi runto subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: create i +PASS: gdb.mi/mi-var-cmd.exp: create l +PASS: gdb.mi/mi-var-cmd.exp: create linteger +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 +XFAIL: gdb.mi/mi-var-cmd.exp: update all vars: changed FIXME +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 (2) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: i changed +PASS: gdb.mi/mi-var-cmd.exp: step at subroutine1 (3) +PASS: gdb.mi/mi-var-cmd.exp: update all vars: llong changed +PASS: gdb.mi/mi-var-cmd.exp: next out of subroutine1 +PASS: gdb.mi/mi-var-cmd.exp: update all vars: all now out of scope +PASS: gdb.mi/mi-var-cmd.exp: delete var +PASS: gdb.mi/mi-var-cmd.exp: delete var linteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lpinteger +PASS: gdb.mi/mi-var-cmd.exp: delete var lcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var lpcharacter +PASS: gdb.mi/mi-var-cmd.exp: delete var llong +PASS: gdb.mi/mi-var-cmd.exp: delete var lplong +PASS: gdb.mi/mi-var-cmd.exp: delete var lfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var lpfloat +PASS: gdb.mi/mi-var-cmd.exp: delete var ldouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lpdouble +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var lpsimple +PASS: gdb.mi/mi-var-cmd.exp: delete var func +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.character +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple->integer +PASS: gdb.mi/mi-var-cmd.exp: delete var lsimple.integer +PASS: gdb.mi/mi-var-cmd.exp: delete var i +PASS: gdb.mi/mi-var-cmd.exp: delete var l +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: create selected_a +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-cmd.exp: mi runto incr_a +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in incr_a +PASS: gdb.mi/mi-var-cmd.exp: step a line in incr_a +PASS: gdb.mi/mi-var-cmd.exp: return from incr_a to do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: update selected_a in do_special_tests +PASS: gdb.mi/mi-var-cmd.exp: floating varobj invalidation +PASS: gdb.mi/mi-var-cmd.exp: delete selected_a +PASS: gdb.mi/mi-var-cmd.exp: delete array_ptr +FAIL: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:351 (set breakpoint) +FAIL: gdb.mi/mi-var-cmd.exp: wait for stop (frozen: step to 351) +FAIL: gdb.mi/mi-var-cmd.exp: frozen: go to line 351 +FAIL: gdb.mi/mi-var-cmd.exp: frozen: step over 351 (MI error) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:510 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create varobj for Data +PASS: gdb.mi/mi-var-cmd.exp: list children of Data +PASS: gdb.mi/mi-var-cmd.exp: access bitfield +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:453 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: create floating varobj +PASS: gdb.mi/mi-var-cmd.exp: update F (1) +PASS: gdb.mi/mi-var-cmd.exp: check F (1) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:464 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (2) +PASS: gdb.mi/mi-var-cmd.exp: check F (2) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:472 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (--all-values) +PASS: gdb.mi/mi-var-cmd.exp: run to var-cmd.c:478 (set breakpoint) +PASS: gdb.mi/mi-var-cmd.exp: update F (3) +PASS: gdb.mi/mi-var-cmd.exp: check F (3) +PASS: gdb.mi/mi-var-cmd.exp: inside breakpoint inside callee +PASS: gdb.mi/mi-var-cmd.exp: continue to where i is initialized +PASS: gdb.mi/mi-var-cmd.exp: update F inside callee +PASS: gdb.mi/mi-var-cmd.exp: check F inside callee +PASS: gdb.mi/mi-var-cmd.exp: create null_ptr +PASS: gdb.mi/mi-var-cmd.exp: update null_ptr +PASS: gdb.mi/mi-var-cmd.exp: delete null_ptr +PASS: gdb.mi/mi-var-cmd.exp: kill program before endvar +PASS: gdb.mi/mi-var-cmd.exp: create endvar +PASS: gdb.mi/mi-var-cmd.exp: update endvar +PASS: gdb.mi/mi-var-cmd.exp: delete endvar +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: create varobj +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: check initial value +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at main +PASS: gdb.mi/mi-var-cmd.exp: mi runto main +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: out of scope now, not changed +PASS: gdb.mi/mi-var-cmd.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now +PASS: gdb.mi/mi-var-cmd.exp: in-and-out-of-scope: in scope now, not changed +Running ./gdb.mi/mi-var-cp.exp ... +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:20 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rx +PASS: gdb.mi/mi-var-cp.exp: update RX (1) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 167 +PASS: gdb.mi/mi-var-cp.exp: update RX (2) +PASS: gdb.mi/mi-var-cp.exp: check RX: expect 567 +PASS: gdb.mi/mi-var-cp.exp: update RX (3) +PASS: gdb.mi/mi-var-cp.exp: delete RX +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:46 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2 +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s +PASS: gdb.mi/mi-var-cp.exp: list children of s2.s.public +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.i +PASS: gdb.mi/mi-var-cp.exp: check S2.S.public.j +PASS: gdb.mi/mi-var-cp.exp: delete S2 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:82 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for rptr_s +PASS: gdb.mi/mi-var-cp.exp: list public child of RPTR +PASS: gdb.mi/mi-var-cp.exp: list children of reference to pointer +PASS: gdb.mi/mi-var-cp.exp: check i member +PASS: gdb.mi/mi-var-cp.exp: check j member +PASS: gdb.mi/mi-var-cp.exp: delete RPTR +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:105 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: create varobj for s +PASS: gdb.mi/mi-var-cp.exp: check attributes of S +PASS: gdb.mi/mi-var-cp.exp: check attributes of R +PASS: gdb.mi/mi-var-cp.exp: -var-update should not list structure varobjs +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:145 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for ip +PASS: gdb.mi/mi-var-cp.exp: list children of IP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression IP.*ip +PASS: gdb.mi/mi-var-cp.exp: create varobj for dp +PASS: gdb.mi/mi-var-cp.exp: list children of DP +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public.i +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1 +PASS: gdb.mi/mi-var-cp.exp: list children of DP.Base1.public +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.Base1.public.i +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression DP.public +PASS: gdb.mi/mi-var-cp.exp: create varobj for d +PASS: gdb.mi/mi-var-cp.exp: list children of D +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression D.Base1 +PASS: gdb.mi/mi-var-cp.exp: run to mi-var-cp.cc:192 (set breakpoint) +PASS: gdb.mi/mi-var-cp.exp: create varobj for array +PASS: gdb.mi/mi-var-cp.exp: list children of A +PASS: gdb.mi/mi-var-cp.exp: -var-info-path-expression A.2 +PASS: gdb.mi/mi-var-cp.exp: break in anonymous_structs_and_unions +PASS: gdb.mi/mi-var-cp.exp: continue to anonymous_structs breakpoint +PASS: gdb.mi/mi-var-cp.exp: VT: create root varobj for a +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1 +PASS: gdb.mi/mi-var-cp.exp: path expression for a1 +PASS: gdb.mi/mi-var-cp.exp: expression for a1 +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.0_anonymous.public.b +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.1_anonymous.public.c +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.d +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.e +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.f +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.i +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.2_anonymous.public.j +PASS: gdb.mi/mi-var-cp.exp: VT: list children of a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.g +PASS: gdb.mi/mi-var-cp.exp: path expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +PASS: gdb.mi/mi-var-cp.exp: expression for a1.public.2_anonymous.public.1_anonymous.public.1_anonymous.public.1_anonymous.public.h +Running ./gdb.mi/mi-var-create-rtti.exp ... +PASS: gdb.mi/mi-var-create-rtti.exp: breakpoint at main +PASS: gdb.mi/mi-var-create-rtti.exp: mi runto main +PASS: gdb.mi/mi-var-create-rtti.exp: -var-create sp1 * $sp +Running ./gdb.mi/mi-var-display.exp ... +PASS: gdb.mi/mi-var-display.exp: break-insert operation +PASS: gdb.mi/mi-var-display.exp: run to main +PASS: gdb.mi/mi-var-display.exp: create local variable bar +PASS: gdb.mi/mi-var-display.exp: info type variable bar +PASS: gdb.mi/mi-var-display.exp: show format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new format +PASS: gdb.mi/mi-var-display.exp: assing to variable bar +PASS: gdb.mi/mi-var-display.exp: set format variable bar +PASS: gdb.mi/mi-var-display.exp: eval variable bar with new value +PASS: gdb.mi/mi-var-display.exp: delete var bar +PASS: gdb.mi/mi-var-display.exp: create local variable foo +PASS: gdb.mi/mi-var-display.exp: info type variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: show format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: assing to variable foo +PASS: gdb.mi/mi-var-display.exp: set format variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo +PASS: gdb.mi/mi-var-display.exp: eval variable foo in hex +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in hex +PASS: gdb.mi/mi-var-display.exp: eval variable foo in octal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in octal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in decimal +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in decimal +PASS: gdb.mi/mi-var-display.exp: eval variable foo in natural +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in natural +PASS: gdb.mi/mi-var-display.exp: eval variable foo in binary +PASS: gdb.mi/mi-var-display.exp: show format variable foo after eval in binary +PASS: gdb.mi/mi-var-display.exp: delete var foo +PASS: gdb.mi/mi-var-display.exp: create local variable weird +PASS: gdb.mi/mi-var-display.exp: get children local variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: show format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird +PASS: gdb.mi/mi-var-display.exp: set format variable weird.integer +PASS: gdb.mi/mi-var-display.exp: set format variable weird.character +PASS: gdb.mi/mi-var-display.exp: set format variable weird.char_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_int +PASS: gdb.mi/mi-var-display.exp: set format variable weird.int_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.long_array +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_struct +PASS: gdb.mi/mi-var-display.exp: set format variable weird.func_ptr_ptr +PASS: gdb.mi/mi-var-display.exp: set format variable weird.u1 +PASS: gdb.mi/mi-var-display.exp: set format variable weird.s2 +PASS: gdb.mi/mi-var-display.exp: delete var weird +PASS: gdb.mi/mi-var-display.exp: break-insert operation 2 +PASS: gdb.mi/mi-var-display.exp: continue to do_special_tests +PASS: gdb.mi/mi-var-display.exp: create local variable u +PASS: gdb.mi/mi-var-display.exp: eval variable u +PASS: gdb.mi/mi-var-display.exp: info type variable u +PASS: gdb.mi/mi-var-display.exp: is u editable +PASS: gdb.mi/mi-var-display.exp: get number of children of u +PASS: gdb.mi/mi-var-display.exp: get children of u +PASS: gdb.mi/mi-var-display.exp: create local variable anonu +PASS: gdb.mi/mi-var-display.exp: eval variable anonu +PASS: gdb.mi/mi-var-display.exp: info type variable anonu +PASS: gdb.mi/mi-var-display.exp: is anonu editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anonu +PASS: gdb.mi/mi-var-display.exp: get children of anonu +PASS: gdb.mi/mi-var-display.exp: create local variable s +PASS: gdb.mi/mi-var-display.exp: eval variable s +PASS: gdb.mi/mi-var-display.exp: info type variable s +PASS: gdb.mi/mi-var-display.exp: is s editable +PASS: gdb.mi/mi-var-display.exp: get number of children of s +PASS: gdb.mi/mi-var-display.exp: get children of s +PASS: gdb.mi/mi-var-display.exp: create local variable anons +PASS: gdb.mi/mi-var-display.exp: eval variable anons +PASS: gdb.mi/mi-var-display.exp: info type variable anons +PASS: gdb.mi/mi-var-display.exp: is anons editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anons +PASS: gdb.mi/mi-var-display.exp: get children of anons +PASS: gdb.mi/mi-var-display.exp: create local variable e +PASS: gdb.mi/mi-var-display.exp: eval variable e +PASS: gdb.mi/mi-var-display.exp: info type variable e +PASS: gdb.mi/mi-var-display.exp: is e editable +PASS: gdb.mi/mi-var-display.exp: get number of children of e +PASS: gdb.mi/mi-var-display.exp: get children of e +PASS: gdb.mi/mi-var-display.exp: create local variable anone +PASS: gdb.mi/mi-var-display.exp: eval variable anone +PASS: gdb.mi/mi-var-display.exp: create duplicate local variable anone +PASS: gdb.mi/mi-var-display.exp: info type variable anone +PASS: gdb.mi/mi-var-display.exp: is anone editable +PASS: gdb.mi/mi-var-display.exp: get number of children of anone +PASS: gdb.mi/mi-var-display.exp: get children of anone +PASS: gdb.mi/mi-var-display.exp: print FP register +PASS: gdb.mi/mi-var-display.exp: breakpoint at incr_a +PASS: gdb.mi/mi-var-display.exp: mi runto incr_a +PASS: gdb.mi/mi-var-display.exp: create local variable a1 +PASS: gdb.mi/mi-var-display.exp: create variable a2 in different scope +Running ./gdb.mi/mi-var-invalidate.exp ... +PASS: gdb.mi/mi-var-invalidate.exp: create global variable +PASS: gdb.mi/mi-var-invalidate.exp: breakpoint at do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: mi runto do_locals_tests +PASS: gdb.mi/mi-var-invalidate.exp: create local variable linteger +PASS: gdb.mi/mi-var-invalidate.exp: create floating variable +FAIL: gdb.mi/mi-var-invalidate.exp: breakpoint at main +FAIL: gdb.mi/mi-var-invalidate.exp: mi runto main (unknown output after running) +PASS: gdb.mi/mi-var-invalidate.exp: set format variable float_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (1) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple still alive +PASS: gdb.mi/mi-var-invalidate.exp: type simpleton for valid variable global_simple +PASS: gdb.mi/mi-var-invalidate.exp: linteger not valid anymore due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable linteger (2) +PASS: gdb.mi/mi-var-invalidate.exp: global_simple not anymore in scope due to binary changes +PASS: gdb.mi/mi-var-invalidate.exp: no type for invalid variable global_simple +Running ./gdb.mi/mi-var-rtti.exp ... +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:37 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (without RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtr.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtr->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtr (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of ptrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check ptrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: list children of constPtrConst.public (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->A (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->B (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: check constPtrConst->C (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constPtrConst (with RTTI) in use_rtti_for_ptr +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:64 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (without RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check ref->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: create varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.Base.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: list children of constRef.public (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->A (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->B (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: check constRef->C (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for constRef (with RTTI) in use_rtti_for_ref +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:94 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtr.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtr->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ptrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.Base.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constPtrConst.public (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->A (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->B (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constPtrConst->C (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ptr_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:149 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (without RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: create varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ref.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.ref->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.Base.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: list children of s.constRef.public (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->A (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->B (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: check s.constRef->C (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s (with RTTI) in use_rtti_for_ref_child +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:202 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ref.public (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: check ref->A (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ref (without RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.First (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr (with RTTI) in use_rtti_with_multiple_inheritence +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:245 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object on" in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: list children of s.public in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in type_update_when_use_rtti +FAIL: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:269 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr to derived in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.Base.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->B (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->C (with RTTI) in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:281 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s.ptr back to base type in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in type_update_when_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:299 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: -interpreter-exec console "set print object off" in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: create varobj for S in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.public in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:323 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s to derived type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: list children of s.ptr.public (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: check s.ptr->A (without RTTI) in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:335 (set breakpoint) +PASS: gdb.mi/mi-var-rtti.exp: update ptr back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for ptr in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: update s back to base type in skip_type_update_when_not_use_rtti +PASS: gdb.mi/mi-var-rtti.exp: delete varobj for s in skip_type_update_when_not_use_rtti +Running ./gdb.mi/mi-watch.exp ... +PASS: gdb.mi/mi-watch.exp: hw watchpoints toggle (1) +PASS: gdb.mi/mi-watch.exp: sw: breakpoint at callee4 +PASS: gdb.mi/mi-watch.exp: sw: mi runto callee4 +PASS: gdb.mi/mi-watch.exp: sw: break-watch operation +PASS: gdb.mi/mi-watch.exp: sw: list of watchpoints +PASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +XPASS: gdb.mi/mi-watch.exp: sw: watchpoint trigger +Running ./gdb.mi/mi-watch-nonstop.exp ... +Running ./gdb.mi/pr11022.exp ... +Running ./gdb.modula2/unbounded-array.exp ... +PASS: gdb.modula2/unbounded-array.exp: switch to modula-2 +PASS: gdb.modula2/unbounded-array.exp: print the last legal element of array a +PASS: gdb.modula2/unbounded-array.exp: print unbounded array contents +PASS: gdb.modula2/unbounded-array.exp: print the 1st element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 2nd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 3rd element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 4th element of array a +PASS: gdb.modula2/unbounded-array.exp: print the 5th element of array a +Running ./gdb.multi/base.exp ... +PASS: gdb.multi/base.exp: add empty inferior 2 +PASS: gdb.multi/base.exp: switch to inferior 2 +PASS: gdb.multi/base.exp: load hangout file in inferior 2 +PASS: gdb.multi/base.exp: add inferior 3 with -exec goodbye +PASS: gdb.multi/base.exp: info inferiors +PASS: gdb.multi/base.exp: info inferior 2 3 +PASS: gdb.multi/base.exp: info inferior 1-2 +PASS: gdb.multi/base.exp: switch to inferior 1 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 1 +PASS: gdb.multi/base.exp: switch to inferior 3 +PASS: gdb.multi/base.exp: 'info functions commonfun' in inferior 3 +PASS: gdb.multi/base.exp: switch back to inferior 1 +PASS: gdb.multi/base.exp: set listsize 1 +PASS: gdb.multi/base.exp: list commonfun in hello +PASS: gdb.multi/base.exp: print hglob +PASS: gdb.multi/base.exp: print glob (hello) +PASS: gdb.multi/base.exp: switch to inferior 3 to print globals +PASS: gdb.multi/base.exp: print gglob +PASS: gdb.multi/base.exp: print glob (goodbye) +PASS: gdb.multi/base.exp: list commonfun in goodbye +PASS: gdb.multi/base.exp: switch to inferior 1 to run it +PASS: gdb.multi/base.exp: break hello +PASS: gdb.multi/base.exp: continue +PASS: gdb.multi/base.exp: remove-inferiors 2-3 +PASS: gdb.multi/base.exp: check remove-inferiors +Running ./gdb.multi/bkpt-multi-exec.exp ... +Running ./gdb.multi/multi-arch-exec.exp ... +Running ./gdb.multi/multi-arch.exp ... +Running ./gdb.multi/watchpoint-multi.exp ... +UNTESTED: gdb.multi/watchpoint-multi.exp: watchpoint-multi.exp +Running ./gdb.objc/basicclass.exp ... +UNSUPPORTED: gdb.objc/basicclass.exp: Couldn't compile ./gdb.objc/basicclass.m: unrecognized error +Running ./gdb.objc/nondebug.exp ... +UNSUPPORTED: gdb.objc/nondebug.exp: Couldn't compile ./gdb.objc/nondebug.m: unrecognized error +Running ./gdb.objc/objcdecode.exp ... +UNSUPPORTED: gdb.objc/objcdecode.exp: Couldn't compile ./gdb.objc/objcdecode.m: unrecognized error +Running ./gdb.objc/print.exp ... +PASS: gdb.objc/print.exp: set language objective-c +PASS: gdb.objc/print.exp: set language to "objective-c" +PASS: gdb.objc/print.exp: check fp + text +PASS: gdb.objc/print.exp: p 1. +PASS: gdb.objc/print.exp: p 1.5 +PASS: gdb.objc/print.exp: p 1.f +PASS: gdb.objc/print.exp: p 1.5f +PASS: gdb.objc/print.exp: p 1.l +PASS: gdb.objc/print.exp: p 1.5l +PASS: gdb.objc/print.exp: p 0x1.1 +PASS: gdb.objc/print.exp: reject p 1.1x +PASS: gdb.objc/print.exp: reject p 1.1ff +PASS: gdb.objc/print.exp: reject p 1.1ll +Running ./gdb.opencl/callfuncs.exp ... +Running ./gdb.opencl/convs_casts.exp ... +Running ./gdb.opencl/datatypes.exp ... +Running ./gdb.opencl/operators.exp ... +Running ./gdb.opencl/vec_comps.exp ... +Running ./gdb.opt/clobbered-registers-O2.exp ... +PASS: gdb.opt/clobbered-registers-O2.exp: Backtracing +PASS: gdb.opt/clobbered-registers-O2.exp: print operand0 +PASS: gdb.opt/clobbered-registers-O2.exp: print operand1 +Running ./gdb.opt/inline-break.exp ... +PASS: gdb.opt/inline-break.exp: break func1 +PASS: gdb.opt/inline-break.exp: break func2 +PASS: gdb.opt/inline-break.exp: break func3b +PASS: gdb.opt/inline-break.exp: break func4b +PASS: gdb.opt/inline-break.exp: break func5b +PASS: gdb.opt/inline-break.exp: break func6b +PASS: gdb.opt/inline-break.exp: break func7b +PASS: gdb.opt/inline-break.exp: break func8b +PASS: gdb.opt/inline-break.exp: print func1 +PASS: gdb.opt/inline-break.exp: print func2 +Running ./gdb.opt/inline-bt.exp ... +PASS: gdb.opt/inline-bt.exp: continue to bar (1) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (1) +PASS: gdb.opt/inline-bt.exp: bar not inlined +PASS: gdb.opt/inline-bt.exp: continue to bar (2) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (2) +PASS: gdb.opt/inline-bt.exp: up from bar (2) +PASS: gdb.opt/inline-bt.exp: func1 inlined (2) +PASS: gdb.opt/inline-bt.exp: continue to bar (3) +PASS: gdb.opt/inline-bt.exp: backtrace from bar (3) +PASS: gdb.opt/inline-bt.exp: up from bar (3) +PASS: gdb.opt/inline-bt.exp: func1 inlined (3) +PASS: gdb.opt/inline-bt.exp: up from func1 (3) +PASS: gdb.opt/inline-bt.exp: func2 inlined (3) +Running ./gdb.opt/inline-cmds.exp ... +PASS: gdb.opt/inline-cmds.exp: set listsize 1 +PASS: gdb.opt/inline-cmds.exp: continue to bar (1) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (1) +PASS: gdb.opt/inline-cmds.exp: up from bar (1) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (1) +PASS: gdb.opt/inline-cmds.exp: continue to bar (2) +PASS: gdb.opt/inline-cmds.exp: backtrace from bar (2) +PASS: gdb.opt/inline-cmds.exp: up from bar (2) +PASS: gdb.opt/inline-cmds.exp: func1 inlined (2) +PASS: gdb.opt/inline-cmds.exp: up from func1 (2) +PASS: gdb.opt/inline-cmds.exp: func2 inlined (2) +PASS: gdb.opt/inline-cmds.exp: continue to marker +PASS: gdb.opt/inline-cmds.exp: backtrace from marker +PASS: gdb.opt/inline-cmds.exp: marker not inlined +PASS: gdb.opt/inline-cmds.exp: next over inlined functions +PASS: gdb.opt/inline-cmds.exp: next past inlined func1 +PASS: gdb.opt/inline-cmds.exp: print x before func1 +PASS: gdb.opt/inline-cmds.exp: backtrace does not include func1 +PASS: gdb.opt/inline-cmds.exp: stepped over call to func1 +PASS: gdb.opt/inline-cmds.exp: step into func1 +PASS: gdb.opt/inline-cmds.exp: finish from func1 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: consecutive func1 +PASS: gdb.opt/inline-cmds.exp: next to first func1 +KFAIL: gdb.opt/inline-cmds.exp: next to second func1 (PRMS: gdb/NNNN) +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: func1 then func3 +PASS: gdb.opt/inline-cmds.exp: next to func1 before func3 +PASS: gdb.opt/inline-cmds.exp: next to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: finish into func1 +PASS: gdb.opt/inline-cmds.exp: next to finish marker +PASS: gdb.opt/inline-cmds.exp: step into finish marker +PASS: gdb.opt/inline-cmds.exp: finish from marker to func1 +PASS: gdb.opt/inline-cmds.exp: step into func1 for finish +PASS: gdb.opt/inline-cmds.exp: finish from func1 to func3 +PASS: gdb.opt/inline-cmds.exp: continue to breakpoint: before the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach 1 the outer_inline call +PASS: gdb.opt/inline-cmds.exp: reach outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at main of outer_inline +PASS: gdb.opt/inline-cmds.exp: enter outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline2 +PASS: gdb.opt/inline-cmds.exp: enter outer_inline1 from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: backtrace at outer_inline1 +PASS: gdb.opt/inline-cmds.exp: enter noinline from outer_inline1 +PASS: gdb.opt/inline-cmds.exp: backtrace at noinline from outer_inline1 +PASS: gdb.opt/inline-cmds.exp: enter inlined_fn from noinline +PASS: gdb.opt/inline-cmds.exp: backtrace at inlined_fn from noinline +PASS: gdb.opt/inline-cmds.exp: inlined_fn from noinline inlined +PASS: gdb.opt/inline-cmds.exp: up to noinline +PASS: gdb.opt/inline-cmds.exp: noinline from outer_inline1 not inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline1 +PASS: gdb.opt/inline-cmds.exp: outer_inline1 inlined +PASS: gdb.opt/inline-cmds.exp: up to outer_inline2 +PASS: gdb.opt/inline-cmds.exp: outer_inline2 inlined +PASS: gdb.opt/inline-cmds.exp: up from outer_inline2 +PASS: gdb.opt/inline-cmds.exp: main not inlined +Running ./gdb.opt/inline-locals.exp ... +PASS: gdb.opt/inline-locals.exp: continue to bar (1) +PASS: gdb.opt/inline-locals.exp: continue to bar (2) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (2) +PASS: gdb.opt/inline-locals.exp: up from bar (2) +PASS: gdb.opt/inline-locals.exp: func1 inlined (2) +PASS: gdb.opt/inline-locals.exp: info locals above bar (2) +PASS: gdb.opt/inline-locals.exp: info args above bar (2) +PASS: gdb.opt/inline-locals.exp: print local (2) +PASS: gdb.opt/inline-locals.exp: print out of scope local +PASS: gdb.opt/inline-locals.exp: continue to bar (3) +PASS: gdb.opt/inline-locals.exp: backtrace from bar (3) +PASS: gdb.opt/inline-locals.exp: up from bar (3) +PASS: gdb.opt/inline-locals.exp: func1 inlined (3) +PASS: gdb.opt/inline-locals.exp: info locals above bar (3) +PASS: gdb.opt/inline-locals.exp: info args above bar (3) +PASS: gdb.opt/inline-locals.exp: print local (3) +Running ./gdb.pascal/floats.exp ... +UNSUPPORTED: gdb.pascal/floats.exp: No pascal compiler found +UNTESTED: gdb.pascal/floats.exp: floats.exp +Running ./gdb.pascal/gdb11492.exp ... +UNSUPPORTED: gdb.pascal/gdb11492.exp: No pascal compiler found +UNTESTED: gdb.pascal/gdb11492.exp: gdb11492.exp +Running ./gdb.pascal/hello.exp ... +UNSUPPORTED: gdb.pascal/hello.exp: No pascal compiler found +Running ./gdb.pascal/integers.exp ... +UNSUPPORTED: gdb.pascal/integers.exp: No pascal compiler found +Running ./gdb.pascal/print.exp ... +PASS: gdb.pascal/print.exp: set language pascal +PASS: gdb.pascal/print.exp: set language to "pascal" +PASS: gdb.pascal/print.exp: check fp + text +PASS: gdb.pascal/print.exp: p 1. +PASS: gdb.pascal/print.exp: p 1.5 +PASS: gdb.pascal/print.exp: p 1.f +PASS: gdb.pascal/print.exp: p 1.5f +PASS: gdb.pascal/print.exp: p 1.l +PASS: gdb.pascal/print.exp: p 1.5l +PASS: gdb.pascal/print.exp: p 0x1.1 +PASS: gdb.pascal/print.exp: reject p 1.1x +PASS: gdb.pascal/print.exp: reject p 1.1ff +PASS: gdb.pascal/print.exp: reject p 1.1ll +Running ./gdb.pascal/types.exp ... +PASS: gdb.pascal/types.exp: set language pascal +PASS: gdb.pascal/types.exp: set language to "pascal" +PASS: gdb.pascal/types.exp: pt 123 +PASS: gdb.pascal/types.exp: pt TRUE +PASS: gdb.pascal/types.exp: pt FALSE +PASS: gdb.pascal/types.exp: pt 'a' +KFAIL: gdb.pascal/types.exp: pt 'a simple string' (PRMS: gdb/2326) +PASS: gdb.pascal/types.exp: pt .44 +PASS: gdb.pascal/types.exp: pt 44.0 +PASS: gdb.pascal/types.exp: pt 10e20 +PASS: gdb.pascal/types.exp: pt 10E20 +Running ./gdb.python/lib-types.exp ... +PASS: gdb.python/lib-types.exp: python import gdb.types +PASS: gdb.python/lib-types.exp: python const_class1_obj = gdb.parse_and_eval ('const_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_class1_obj = gdb.types.get_basic_type (const_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_class1_obj.type)) +PASS: gdb.python/lib-types.exp: const stripping +PASS: gdb.python/lib-types.exp: python volatile_class1_obj = gdb.parse_and_eval ('volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_volatile_class1_obj = gdb.types.get_basic_type (volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile stripping +PASS: gdb.python/lib-types.exp: python const_volatile_class1_obj = gdb.parse_and_eval ('const_volatile_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_const_volatile_class1_obj = gdb.types.get_basic_type (const_volatile_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (const_volatile_class1_obj.type)) +PASS: gdb.python/lib-types.exp: volatile+const stripping +PASS: gdb.python/lib-types.exp: python typedef_class1_obj = gdb.parse_and_eval ('typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_class1_obj = gdb.types.get_basic_type (typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: typedef stripping +PASS: gdb.python/lib-types.exp: python class1_ref_obj = gdb.parse_and_eval ('class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_class1_ref_obj = gdb.types.get_basic_type (class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: reference stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_class1_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef stripping +PASS: gdb.python/lib-types.exp: python typedef_const_typedef_class1_ref_obj = gdb.parse_and_eval ('typedef_const_typedef_class1_ref_obj') +PASS: gdb.python/lib-types.exp: python basic_type_typedef_const_typedef_class1_ref_obj = gdb.types.get_basic_type (typedef_const_typedef_class1_ref_obj.type) +PASS: gdb.python/lib-types.exp: python print (str (typedef_const_typedef_class1_ref_obj.type)) +PASS: gdb.python/lib-types.exp: nested typedef/ref stripping +PASS: gdb.python/lib-types.exp: python class1_obj = gdb.parse_and_eval ('class1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (class1_obj.type, 'nope')) +PASS: gdb.python/lib-types.exp: python subclass1_obj = gdb.parse_and_eval ('subclass1_obj') +PASS: gdb.python/lib-types.exp: python print (gdb.types.has_field (subclass1_obj.type, 'x')) +PASS: gdb.python/lib-types.exp: python enum1_obj = gdb.parse_and_eval ('enum1_obj') +PASS: gdb.python/lib-types.exp: python enum1_dict = gdb.types.make_enum_dict (enum1_obj.type) +PASS: gdb.python/lib-types.exp: python enum1_list = sorted (enum1_dict.items ()) +PASS: gdb.python/lib-types.exp: python print (enum1_list) +PASS: gdb.python/lib-types.exp: python struct_a = gdb.lookup_type ('struct A') +PASS: gdb.python/lib-types.exp: python print (struct_a.keys ()) +PASS: gdb.python/lib-types.exp: python print ([k for k,v in gdb.types.deep_items(struct_a)]) +Running ./gdb.python/py-arch.exp ... +PASS: gdb.python/py-arch.exp: test number of instructions 1 +PASS: gdb.python/py-arch.exp: test number of instructions 2 +PASS: gdb.python/py-arch.exp: test number of instructions 3 +PASS: gdb.python/py-arch.exp: test number of instructions 4 +PASS: gdb.python/py-arch.exp: test key addr +PASS: gdb.python/py-arch.exp: test key asm +PASS: gdb.python/py-arch.exp: test key length +PASS: gdb.python/py-arch.exp: test exception +Running ./gdb.python/py-block.exp ... +PASS: gdb.python/py-block.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-block.exp: Check block not None +PASS: gdb.python/py-block.exp: First anonymous block +PASS: gdb.python/py-block.exp: Check start not None +PASS: gdb.python/py-block.exp: Check end not None +PASS: gdb.python/py-block.exp: Not a global block +PASS: gdb.python/py-block.exp: Not a static block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Get block +PASS: gdb.python/py-block.exp: Is the global block +PASS: gdb.python/py-block.exp: Is the static block +PASS: gdb.python/py-block.exp: Get superblock +PASS: gdb.python/py-block.exp: Second anonymous block +PASS: gdb.python/py-block.exp: Get superblock 2 +PASS: gdb.python/py-block.exp: Print superblock 2 function +PASS: gdb.python/py-block.exp: up +PASS: gdb.python/py-block.exp: Check Frame 2's block not None +PASS: gdb.python/py-block.exp: main block +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +PASS: gdb.python/py-block.exp: Check block validity +Running ./gdb.python/py-breakpoint.exp ... +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check for two breakpoints +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint hit count +PASS: gdb.python/py-breakpoint.exp: Check expected variable result after 6 iterations +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint enabled. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at add. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint thread +PASS: gdb.python/py-breakpoint.exp: Check breakpoint type +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Check breakpoint number +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints before delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check breakpoint invalidated +PASS: gdb.python/py-breakpoint.exp: Number of breakpoints after delete +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional has been set +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test conditional breakpoint stopped after five iterations +PASS: gdb.python/py-breakpoint.exp: Test conditional read +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test breakpoint stopped after six iterations +PASS: gdb.python/py-breakpoint.exp: commands $bpnum +PASS: gdb.python/py-breakpoint.exp: print "Command for breakpoint has been executed." +PASS: gdb.python/py-breakpoint.exp: print result +PASS: gdb.python/py-breakpoint.exp: end +PASS: gdb.python/py-breakpoint.exp: python print (blist[len(blist)-1].commands) +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints shows visible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check invisible bp obj exists +PASS: gdb.python/py-breakpoint.exp: Check breakpoint location +PASS: gdb.python/py-breakpoint.exp: Check breakpoint visibility +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check info breakpoints does not show invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Check maint info breakpoints shows invisible breakpoints +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - class bp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - inf_i = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - self.inf_i = gdb.parse_and_eval("i") +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - if self.inf_i == 3: +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - class bp_also_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - self.count = self.count + 1 +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - if self.count == 9: +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a second breakpoint - end +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - class basic (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - count = 0 +PASS: gdb.python/py-breakpoint.exp: Sub-class a third breakpoint - end +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Check inferior value matches python accounting +PASS: gdb.python/py-breakpoint.exp: Check python accounting matches inferior +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check non firing same-location breakpoint eval function was also called at each stop. +PASS: gdb.python/py-breakpoint.exp: Check you cannot add a CLI condition to a Python breakpoint that +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - python +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - def stop_func (): +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - return True +PASS: gdb.python/py-breakpoint.exp: Construct an eval function - end +PASS: gdb.python/py-breakpoint.exp: Assign stop function to a breakpoint that has a condition +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function has not been yet executed (ie count = 0) +PASS: gdb.python/py-breakpoint.exp: continue to breakpoint: Break at multiply. +PASS: gdb.python/py-breakpoint.exp: Test that evaluate function is run when location also has normal bp +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - python +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - class wp_eval (gdb.Breakpoint): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - def stop (self): +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - self.result = gdb.parse_and_eval("result") +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - if self.result == 788: +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return True +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - return False +PASS: gdb.python/py-breakpoint.exp: Sub-class a watchpoint - end +PASS: gdb.python/py-breakpoint.exp: Test watchpoint write +PASS: gdb.python/py-breakpoint.exp: Check that this unrelated breakpoints eval function was never called. +Running ./gdb.python/py-cmd.exp ... +PASS: gdb.python/py-cmd.exp: input simple command - python +PASS: gdb.python/py-cmd.exp: input simple command - class test_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple command - super (test_cmd, self).__init__ ("test_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input simple command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple command - test_cmd () +PASS: gdb.python/py-cmd.exp: input simple command - end +PASS: gdb.python/py-cmd.exp: call simple command +PASS: gdb.python/py-cmd.exp: input prefix command - python +PASS: gdb.python/py-cmd.exp: input prefix command - class prefix_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command - super (prefix_cmd, self).__init__ ("prefix_cmd", gdb.COMMAND_OBSCURE, gdb.COMPLETE_NONE, True) +PASS: gdb.python/py-cmd.exp: input prefix command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command - print ("prefix_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command - prefix_cmd () +PASS: gdb.python/py-cmd.exp: input prefix command - end +PASS: gdb.python/py-cmd.exp: call prefix command +PASS: gdb.python/py-cmd.exp: input subcommand - python +PASS: gdb.python/py-cmd.exp: input subcommand - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand - super (subcmd, self).__init__ ("prefix_cmd subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand - end +PASS: gdb.python/py-cmd.exp: call subcmd +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - python +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - class prefix_cmd2 (gdb.Command): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - super (prefix_cmd2, self).__init__ ("prefix_cmd2", gdb.COMMAND_OBSCURE, prefix = True, completer_class = gdb.COMPLETE_FILENAME) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - print ("prefix_cmd2 output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - prefix_cmd2 () +PASS: gdb.python/py-cmd.exp: input prefix command, keyword arguments - end +PASS: gdb.python/py-cmd.exp: call prefix command, keyword arguments +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - python +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - class subcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - super (subcmd, self).__init__ ("prefix_cmd2 subcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - print ("subcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - subcmd () +PASS: gdb.python/py-cmd.exp: input subcommand under prefix_cmd2 - end +PASS: gdb.python/py-cmd.exp: call subcmd under prefix_cmd2 +PASS: gdb.python/py-cmd.exp: input new subcommand - python +PASS: gdb.python/py-cmd.exp: input new subcommand - class newsubcmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input new subcommand - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input new subcommand - super (newsubcmd, self).__init__ ("info newsubcmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input new subcommand - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input new subcommand - print ("newsubcmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input new subcommand - newsubcmd () +PASS: gdb.python/py-cmd.exp: input new subcommand - end +PASS: gdb.python/py-cmd.exp: call newsubcmd +PASS: gdb.python/py-cmd.exp: input command to throw error - python +PASS: gdb.python/py-cmd.exp: input command to throw error - class test_error_cmd (gdb.Command): +PASS: gdb.python/py-cmd.exp: input command to throw error - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input command to throw error - super (test_error_cmd, self).__init__ ("test_error_cmd", gdb.COMMAND_OBSCURE) +PASS: gdb.python/py-cmd.exp: input command to throw error - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input command to throw error - raise gdb.GdbError ('you lose!') +PASS: gdb.python/py-cmd.exp: input command to throw error - test_error_cmd () +PASS: gdb.python/py-cmd.exp: input command to throw error - end +PASS: gdb.python/py-cmd.exp: call error command +PASS: gdb.python/py-cmd.exp: string_to_argv ("1 2 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ("'1 2' 3") +PASS: gdb.python/py-cmd.exp: string_to_argv ('"1 2" 3') +PASS: gdb.python/py-cmd.exp: string_to_argv ('1\ 2 3') +PASS: gdb.python/py-cmd.exp: input simple user-defined command - python +PASS: gdb.python/py-cmd.exp: input simple user-defined command - class test_help (gdb.Command): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - """Docstring""" +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def __init__ (self): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - super (test_help, self).__init__ ("test_help", gdb.COMMAND_USER) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - def invoke (self, arg, from_tty): +PASS: gdb.python/py-cmd.exp: input simple user-defined command - print ("test_cmd output, arg = %s" % arg) +PASS: gdb.python/py-cmd.exp: input simple user-defined command - test_help () +PASS: gdb.python/py-cmd.exp: input simple user-defined command - end +PASS: gdb.python/py-cmd.exp: call simple user-defined command +PASS: gdb.python/py-cmd.exp: see user-defined command in `help user-defined` +Running ./gdb.python/py-error.exp ... +PASS: gdb.python/py-error.exp: set host-charset IBM1047 +PASS: gdb.python/py-error.exp: main reached +PASS: gdb.python/py-error.exp: no delayed error +Running ./gdb.python/py-events.exp ... +Running ./gdb.python/py-evsignal.exp ... +KFAIL: gdb.python/py-evsignal.exp: Signal Thread 3 (PRMS: python/12966) +Running ./gdb.python/py-evthreads.exp ... +KFAIL: gdb.python/py-evthreads.exp: Run to breakpoint 1 (PRMS: python/12966) +Running ./gdb.python/py-explore-cc.exp ... +PASS: gdb.python/py-explore-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore-cc.exp: explore A +PASS: gdb.python/py-explore-cc.exp: explore a +PASS: gdb.python/py-explore-cc.exp: explore int_ref +PASS: gdb.python/py-explore-cc.exp: explore int_ptr_ref +PASS: gdb.python/py-explore-cc.exp: explore_int_ptr_ref_as_single_value_pointer +PASS: gdb.python/py-explore-cc.exp: explore b +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_A +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_b +PASS: gdb.python/py-explore-cc.exp: return_to_b_from_i +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_b +PASS: gdb.python/py-explore-cc.exp: explore B +PASS: gdb.python/py-explore-cc.exp: explore_base_class_A +PASS: gdb.python/py-explore-cc.exp: return_to_B +PASS: gdb.python/py-explore-cc.exp: explore_field_i_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_i +PASS: gdb.python/py-explore-cc.exp: explore_field_c_of_B +PASS: gdb.python/py-explore-cc.exp: return_to_B_from_c +PASS: gdb.python/py-explore-cc.exp: return_to_gdb_prompt_from_B +Running ./gdb.python/py-explore.exp ... +PASS: gdb.python/py-explore.exp: continue to breakpoint: Break here +PASS: gdb.python/py-explore.exp: explore i +PASS: gdb.python/py-explore.exp: explore ss +PASS: gdb.python/py-explore.exp: explore *ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_t +PASS: gdb.python/py-explore.exp: explore ss_ptr +PASS: gdb.python/py-explore.exp: explore ss_ptr as single value pointer +PASS: gdb.python/py-explore.exp: explore darray_ref +PASS: gdb.python/py-explore.exp: no_to_explore_as_pointer +PASS: gdb.python/py-explore.exp: explore_as_array +PASS: gdb.python/py-explore.exp: explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array_index_2 +PASS: gdb.python/py-explore.exp: end explore_as_array +PASS: gdb.python/py-explore.exp: explore su +PASS: gdb.python/py-explore.exp: explore su.d +PASS: gdb.python/py-explore.exp: end su.d exploration +PASS: gdb.python/py-explore.exp: end su exploration +PASS: gdb.python/py-explore.exp: explore cs +PASS: gdb.python/py-explore.exp: explore cs.s +PASS: gdb.python/py-explore.exp: end cs.s exploration +PASS: gdb.python/py-explore.exp: explore cs.u +PASS: gdb.python/py-explore.exp: end cs.u exploration +PASS: gdb.python/py-explore.exp: end cs exploration +PASS: gdb.python/py-explore.exp: explore cu +PASS: gdb.python/py-explore.exp: explore cu.sa +PASS: gdb.python/py-explore.exp: explore cu.sa[0] +PASS: gdb.python/py-explore.exp: end cu.sa[0] exploration +PASS: gdb.python/py-explore.exp: end cu.sa exploration +PASS: gdb.python/py-explore.exp: end cu exploration +PASS: gdb.python/py-explore.exp: explore int +PASS: gdb.python/py-explore.exp: explore struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 0 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct SimpleStruct feild 1 +PASS: gdb.python/py-explore.exp: return to struct SimpleStruct from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from struct SimpleStruct +PASS: gdb.python/py-explore.exp: explore union SimpleUnion +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 0 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 1 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 1 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 2 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 2 +PASS: gdb.python/py-explore.exp: explore type union SimpleUnion feild 3 +PASS: gdb.python/py-explore.exp: return to union SimpleUnion from field 3 +PASS: gdb.python/py-explore.exp: return to GDB prompt from union SimpleUnion +PASS: gdb.python/py-explore.exp: explore SS +PASS: gdb.python/py-explore.exp: explore type SS feild 0 +PASS: gdb.python/py-explore.exp: return to SS from field 0 +PASS: gdb.python/py-explore.exp: explore type SS feild 1 +PASS: gdb.python/py-explore.exp: return to SS field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from SS +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 0 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 0 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 1 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 1 +PASS: gdb.python/py-explore.exp: explore type struct ComplexStruct field 2 +PASS: gdb.python/py-explore.exp: return to ComplexStruct from field 2 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexStruct type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 0 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 0 +PASS: gdb.python/py-explore.exp: explore type union ComplexUnion field 1 +PASS: gdb.python/py-explore.exp: return to ComplexUnion from field 1 +PASS: gdb.python/py-explore.exp: return to GDB prompt from ComplexUnion type exploration +Running ./gdb.python/py-finish-breakpoint2.exp ... +PASS: gdb.python/py-finish-breakpoint2.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint2.exp: run to exception 1 +PASS: gdb.python/py-finish-breakpoint2.exp: check BP count +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: check FinishBreakpoint in catch() +PASS: gdb.python/py-finish-breakpoint2.exp: check finish BP removal +PASS: gdb.python/py-finish-breakpoint2.exp: continue to second exception +PASS: gdb.python/py-finish-breakpoint2.exp: set FinishBP after the exception +PASS: gdb.python/py-finish-breakpoint2.exp: FinishBreakpoint with exception thrown not caught +Running ./gdb.python/py-finish-breakpoint.exp ... +PASS: gdb.python/py-finish-breakpoint.exp: disable confirmation +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: continue to the function to finish +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint with default frame value +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check return_value at init +PASS: gdb.python/py-finish-breakpoint.exp: check MyFinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return_value +PASS: gdb.python/py-finish-breakpoint.exp: check finishBP on default frame has been hit +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer normal hit +PASS: gdb.python/py-finish-breakpoint.exp: return to main() +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP not allowed in main +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: ensure that shared lib has no debug info +PASS: gdb.python/py-finish-breakpoint.exp: continue to do_nothing +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBreakpoint hit +PASS: gdb.python/py-finish-breakpoint.exp: check return value without debug symbol +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set finish breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: set BP after the jump +PASS: gdb.python/py-finish-breakpoint.exp: check FinishBP out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: ensure that finish bp is invalid afer out of scope notification +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set a conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP in a breakpoint condition +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: set conditional BP +PASS: gdb.python/py-finish-breakpoint.exp: set BP in condition +PASS: gdb.python/py-finish-breakpoint.exp: stop in condition function +PASS: gdb.python/py-finish-breakpoint.exp: finish condition evaluation +PASS: gdb.python/py-finish-breakpoint.exp: stop at conditional breakpoint +PASS: gdb.python/py-finish-breakpoint.exp: check stopped location +PASS: gdb.python/py-finish-breakpoint.exp: import python scripts +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: don't allow FinishBreakpoint on dummy frames +PASS: gdb.python/py-finish-breakpoint.exp: prepare TestExplicitBreakpoint +PASS: gdb.python/py-finish-breakpoint.exp: FinishBP stop at during explicit function call +PASS: gdb.python/py-finish-breakpoint.exp: switch to exit() test +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exit() +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exit +PASS: gdb.python/py-finish-breakpoint.exp: set FinishBP after the exec +PASS: gdb.python/py-finish-breakpoint.exp: catch exec +PASS: gdb.python/py-finish-breakpoint.exp: catch out of scope after exec +Running ./gdb.python/py-frame.exp ... +PASS: gdb.python/py-frame.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame.exp: test Frame.architecture() +PASS: gdb.python/py-frame.exp: test i +PASS: gdb.python/py-frame.exp: test f +PASS: gdb.python/py-frame.exp: test b +PASS: gdb.python/py-frame.exp: test i = 1.1 +PASS: gdb.python/py-frame.exp: test double i +PASS: gdb.python/py-frame.exp: test f = 2.2 +PASS: gdb.python/py-frame.exp: test double f +PASS: gdb.python/py-frame.exp: test i = 99 +PASS: gdb.python/py-frame.exp: test int i +PASS: gdb.python/py-frame.exp: continue to breakpoint: breakpoint at f2 +PASS: gdb.python/py-frame.exp: selected frame -vs- newest frame +PASS: gdb.python/py-frame.exp: newest frame -vs- newest frame +PASS: gdb.python/py-frame.exp: test equality comparison (false) +PASS: gdb.python/py-frame.exp: test equality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (true) +PASS: gdb.python/py-frame.exp: test inequality comparison (false) +PASS: gdb.python/py-frame.exp: test Frame.is_valid +PASS: gdb.python/py-frame.exp: test Frame.name +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test Frame.type +PASS: gdb.python/py-frame.exp: test gdb.frame_stop_reason_string +PASS: gdb.python/py-frame.exp: test Frame.pc +PASS: gdb.python/py-frame.exp: test Frame.older +PASS: gdb.python/py-frame.exp: test Frame.newer +PASS: gdb.python/py-frame.exp: test Frame.read_var - error +PASS: gdb.python/py-frame.exp: test Frame.read_var - success +PASS: gdb.python/py-frame.exp: test gdb.selected_frame +Running ./gdb.python/py-frame-inline.exp ... +PASS: gdb.python/py-frame-inline.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-frame-inline.exp: info frame +PASS: gdb.python/py-frame-inline.exp: up +PASS: gdb.python/py-frame-inline.exp: python print (gdb.selected_frame().read_var('l')) +Running ./gdb.python/py-function.exp ... +PASS: gdb.python/py-function.exp: input convenience function - python +PASS: gdb.python/py-function.exp: input convenience function - class test_func (gdb.Function): +PASS: gdb.python/py-function.exp: input convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input convenience function - super (test_func, self).__init__ ("test_func") +PASS: gdb.python/py-function.exp: input convenience function - def invoke (self, arg): +PASS: gdb.python/py-function.exp: input convenience function - return "test_func output, arg = %s" % arg.string () +PASS: gdb.python/py-function.exp: input convenience function - test_func () +PASS: gdb.python/py-function.exp: input convenience function - end +PASS: gdb.python/py-function.exp: call function +PASS: gdb.python/py-function.exp: input value-returning convenience function - python +PASS: gdb.python/py-function.exp: input value-returning convenience function - class Double (gdb.Function): +PASS: gdb.python/py-function.exp: input value-returning convenience function - def __init__ (self): +PASS: gdb.python/py-function.exp: input value-returning convenience function - super (Double, self).__init__ ("double") +PASS: gdb.python/py-function.exp: input value-returning convenience function - def invoke (self, n): +PASS: gdb.python/py-function.exp: input value-returning convenience function - return n*2 +PASS: gdb.python/py-function.exp: input value-returning convenience function - Double () +PASS: gdb.python/py-function.exp: input value-returning convenience function - end +PASS: gdb.python/py-function.exp: call value-returning function +PASS: gdb.python/py-function.exp: input int-returning function - python +PASS: gdb.python/py-function.exp: input int-returning function - class Yes(gdb.Function): +PASS: gdb.python/py-function.exp: input int-returning function - def __init__(self): +PASS: gdb.python/py-function.exp: input int-returning function - gdb.Function.__init__(self, 'yes') +PASS: gdb.python/py-function.exp: input int-returning function - def invoke(self): +PASS: gdb.python/py-function.exp: input int-returning function - return 1 +PASS: gdb.python/py-function.exp: input int-returning function - Yes () +PASS: gdb.python/py-function.exp: input int-returning function - end +PASS: gdb.python/py-function.exp: call yes with && +PASS: gdb.python/py-function.exp: call yes with || +PASS: gdb.python/py-function.exp: Test GDBError - python +PASS: gdb.python/py-function.exp: Test GDBError - class GDBError(gdb.Function): +PASS: gdb.python/py-function.exp: Test GDBError - def __init__(self): +PASS: gdb.python/py-function.exp: Test GDBError - gdb.Function.__init__(self, 'gdberror') +PASS: gdb.python/py-function.exp: Test GDBError - def invoke(self): +PASS: gdb.python/py-function.exp: Test GDBError - raise gdb.GdbError("This is a GdbError") +PASS: gdb.python/py-function.exp: Test GDBError - GDBError () +PASS: gdb.python/py-function.exp: Test GDBError - end +PASS: gdb.python/py-function.exp: Test GdbError. There should not be a stack trace +PASS: gdb.python/py-function.exp: Test Normal Error - python +PASS: gdb.python/py-function.exp: Test Normal Error - class NormalError(gdb.Function): +PASS: gdb.python/py-function.exp: Test Normal Error - def __init__(self): +PASS: gdb.python/py-function.exp: Test Normal Error - gdb.Function.__init__(self, 'normalerror') +PASS: gdb.python/py-function.exp: Test Normal Error - def invoke(self): +PASS: gdb.python/py-function.exp: Test Normal Error - raise RuntimeError("This is a Normal Error") +PASS: gdb.python/py-function.exp: Test Normal Error - NormalError () +PASS: gdb.python/py-function.exp: Test Normal Error - end +PASS: gdb.python/py-function.exp: set python print-stack full +PASS: gdb.python/py-function.exp: Test a Runtime error. There should be a stack trace. +PASS: gdb.python/py-function.exp: input command-calling function - python +PASS: gdb.python/py-function.exp: input command-calling function - class CallCommand(gdb.Function): +PASS: gdb.python/py-function.exp: input command-calling function - def __init__(self): +PASS: gdb.python/py-function.exp: input command-calling function - gdb.Function.__init__(self, 'call_command') +PASS: gdb.python/py-function.exp: input command-calling function - def invoke(self): +PASS: gdb.python/py-function.exp: input command-calling function - return gdb.execute('print 1', to_string=True) +PASS: gdb.python/py-function.exp: input command-calling function - CallCommand () +PASS: gdb.python/py-function.exp: input command-calling function - end +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command. +PASS: gdb.python/py-function.exp: Setting a value from a function which executes a command, again. +Running ./gdb.python/py-inferior.exp ... +PASS: gdb.python/py-inferior.exp: successfully compiled posix threads test case +PASS: gdb.python/py-inferior.exp: get inferiors list +PASS: gdb.python/py-inferior.exp: verify inferiors list +PASS: gdb.python/py-inferior.exp: test equality comparison (true) +PASS: gdb.python/py-inferior.exp: test Inferior.num +PASS: gdb.python/py-inferior.exp: test Inferior.pid +PASS: gdb.python/py-inferior.exp: test Inferior.was_attached +PASS: gdb.python/py-inferior.exp: test Inferior.threads +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to check_threads +PASS: gdb.python/py-inferior.exp: test Inferior.threads 2 +PASS: gdb.python/py-inferior.exp: continue to breakpoint: cont to Break here. +PASS: gdb.python/py-inferior.exp: read str contents +PASS: gdb.python/py-inferior.exp: write str +PASS: gdb.python/py-inferior.exp: ensure str was changed in the inferior +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: find string pattern +PASS: gdb.python/py-inferior.exp: pattern not found at end of range +PASS: gdb.python/py-inferior.exp: pattern found at end of range +PASS: gdb.python/py-inferior.exp: py from struct import * +PASS: gdb.python/py-inferior.exp: set int16_search_buf[10] = 0x1234 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int16_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<H',0x1234) +PASS: gdb.python/py-inferior.exp: find 16-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set int32_search_buf[10] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int32_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I',0x12345678) +PASS: gdb.python/py-inferior.exp: find 32-bit pattern, with python pattern +PASS: gdb.python/py-inferior.exp: set int64_search_buf[10] = 0xfedcba9876543210LL +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('int64_search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf.address +PASS: gdb.python/py-inferior.exp: py length = search_buf.type.sizeof +PASS: gdb.python/py-inferior.exp: py pattern = pack('<Q', 0xfedcba9876543210) +PASS: gdb.python/py-inferior.exp: find 64-bit pattern, with value pattern +PASS: gdb.python/py-inferior.exp: set *(int8_t*) &search_buf[10] = 0x62 +PASS: gdb.python/py-inferior.exp: set *(int16_t*) &search_buf[11] = 0x6363 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[13] = 0x64646464 +PASS: gdb.python/py-inferior.exp: py search_buf = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py start_addr = search_buf[0].address +PASS: gdb.python/py-inferior.exp: py pattern1 = pack('B', 0x62) +PASS: gdb.python/py-inferior.exp: py pattern2 = pack('<H', 0x6363) +PASS: gdb.python/py-inferior.exp: py pattern3 = pack('<I', 0x64646464) +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: find mixed-sized pattern +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[0*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: set *(int32_t*) &search_buf[1*16000+100] = 0x12345678 +PASS: gdb.python/py-inferior.exp: py start_addr = gdb.selected_frame ().read_var ('search_buf') +PASS: gdb.python/py-inferior.exp: py end_addr = start_addr + gdb.selected_frame ().read_var ('search_buf_size') +PASS: gdb.python/py-inferior.exp: py pattern = pack('<I', 0x12345678) +PASS: gdb.python/py-inferior.exp: py first = gdb.inferiors()[0].search_memory (start_addr,end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 1st result +PASS: gdb.python/py-inferior.exp: py start_addr = first + 1 +PASS: gdb.python/py-inferior.exp: py second = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 2nd result +PASS: gdb.python/py-inferior.exp: py start_addr = second + 1 +PASS: gdb.python/py-inferior.exp: py third = gdb.inferiors()[0].search_memory (start_addr, end_addr - start_addr, pattern) +PASS: gdb.python/py-inferior.exp: search spanning large range 3rd result +PASS: gdb.python/py-inferior.exp: get initial list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: add empty inferior 2 +PASS: gdb.python/py-inferior.exp: get new list +PASS: gdb.python/py-inferior.exp: Get inferior list length +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: remove-inferiors 3 +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Check inferior validity +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: First inferior selected +PASS: gdb.python/py-inferior.exp: Create new inferior +PASS: gdb.python/py-inferior.exp: Switch to third inferior +PASS: gdb.python/py-inferior.exp: Third inferior selected +PASS: gdb.python/py-inferior.exp: Switch to first inferior +PASS: gdb.python/py-inferior.exp: Remove second inferior +Running ./gdb.python/py-infthread.exp ... +PASS: gdb.python/py-infthread.exp: test gdb.selected_thread +PASS: gdb.python/py-infthread.exp: verify InferiorThread object +PASS: gdb.python/py-infthread.exp: test Inferior.num +PASS: gdb.python/py-infthread.exp: test InferiorThread.ptid +PASS: gdb.python/py-infthread.exp: get supplied name of current thread +PASS: gdb.python/py-infthread.exp: set name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread +PASS: gdb.python/py-infthread.exp: reset name of current thread +PASS: gdb.python/py-infthread.exp: check name of current thread again +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_stopped +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_running +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_exited +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +PASS: gdb.python/py-infthread.exp: kill inferior 1 +PASS: gdb.python/py-infthread.exp: test InferiorThread.is_valid +Running ./gdb.python/py-mi.exp ... +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 328 (set breakpoint) +PASS: gdb.python/py-mi.exp: create container varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine container children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create nscont varobj, no pretty-printing +PASS: gdb.python/py-mi.exp: examine nscont children=0, no pretty-printing +PASS: gdb.python/py-mi.exp: delete varobj +PASS: gdb.python/py-mi.exp: create string_1 varobj +PASS: gdb.python/py-mi.exp: create estring varobj +PASS: gdb.python/py-mi.exp: assign string_1 from string_2 +PASS: gdb.python/py-mi.exp: update string varobj after assignment +PASS: gdb.python/py-mi.exp: create container varobj +PASS: gdb.python/py-mi.exp: examine container children=0 +PASS: gdb.python/py-mi.exp: next over update 1 +PASS: gdb.python/py-mi.exp: varobj update 1 +PASS: gdb.python/py-mi.exp: next over update 2 +PASS: gdb.python/py-mi.exp: varobj update 2 +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: varobj update after choosing default +PASS: gdb.python/py-mi.exp: choose visualizer using expression +PASS: gdb.python/py-mi.exp: varobj update after choosing via expression +PASS: gdb.python/py-mi.exp: list varobj children after selecting child range +PASS: gdb.python/py-mi.exp: list varobj children after resetting child range +PASS: gdb.python/py-mi.exp: next over update 3 +PASS: gdb.python/py-mi.exp: set update range +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: list selected children after setting range +PASS: gdb.python/py-mi.exp: list children after listing selected range +PASS: gdb.python/py-mi.exp: next over update 4 +PASS: gdb.python/py-mi.exp: update after next with restricted range +PASS: gdb.python/py-mi.exp: set update range with non-zero start +PASS: gdb.python/py-mi.exp: update varobj with change outside selected range +PASS: gdb.python/py-mi.exp: next over update 5 +PASS: gdb.python/py-mi.exp: create second container varobj +PASS: gdb.python/py-mi.exp: update varobj, no children requested +PASS: gdb.python/py-mi.exp: next over update 6 +PASS: gdb.python/py-mi.exp: update varobj 2, no children requested +PASS: gdb.python/py-mi.exp: run to 131 (set breakpoint) +PASS: gdb.python/py-mi.exp: create outer varobj +PASS: gdb.python/py-mi.exp: list children of outer +PASS: gdb.python/py-mi.exp: list children of outer.s +PASS: gdb.python/py-mi.exp: next over outer update +PASS: gdb.python/py-mi.exp: update after updating element of outer +PASS: gdb.python/py-mi.exp: run to 222 (set breakpoint) +PASS: gdb.python/py-mi.exp: update after type change +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create nstype varobj +PASS: gdb.python/py-mi.exp: list children after setting update range +PASS: gdb.python/py-mi.exp: clear visualizer +PASS: gdb.python/py-mi.exp: varobj update after clearing +PASS: gdb.python/py-mi.exp: choose default visualizer +PASS: gdb.python/py-mi.exp: create nstype2 varobj +PASS: gdb.python/py-mi.exp: list children after setting exception flag +PASS: gdb.python/py-mi.exp: create me varobj +PASS: gdb.python/py-mi.exp: evaluate me varobj +PASS: gdb.python/py-mi.exp: printer whose children are returned as a list +PASS: gdb.python/py-mi.exp: run to 254 (set breakpoint) +PASS: gdb.python/py-mi.exp: create varobj for c +PASS: gdb.python/py-mi.exp: choose array visualizer for c +PASS: gdb.python/py-mi.exp: list children of c +PASS: gdb.python/py-mi.exp: next over change of array element +PASS: gdb.python/py-mi.exp: update varobj after element change +PASS: gdb.python/py-mi.exp: breakpoint at main +PASS: gdb.python/py-mi.exp: mi runto main +PASS: gdb.python/py-mi.exp: run to 351 (set breakpoint) +PASS: gdb.python/py-mi.exp: create fake varobj +PASS: gdb.python/py-mi.exp: list children of fake +PASS: gdb.python/py-mi.exp: list children fake.private +PASS: gdb.python/py-mi.exp: Install visualizer on a cplus_fake_child +Running ./gdb.python/py-objfile.exp ... +PASS: gdb.python/py-objfile.exp: Find a symbol in objfile +PASS: gdb.python/py-objfile.exp: Get backing object file +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity +PASS: gdb.python/py-objfile.exp: Get objfile validity after unload +Running ./gdb.python/py-objfile-script.exp ... +PASS: gdb.python/py-objfile-script.exp: set auto-load safe-path +PASS: gdb.python/py-objfile-script.exp: info auto-load python-scripts +PASS: gdb.python/py-objfile-script.exp: b 38 +PASS: gdb.python/py-objfile-script.exp: continue +PASS: gdb.python/py-objfile-script.exp: print ss +Running ./gdb.python/py-parameter.exp ... +PASS: gdb.python/py-parameter.exp: python print (gdb.parameter ('directories')) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "Show the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the boolean test-param" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: enum gdb parameter - python +PASS: gdb.python/py-parameter.exp: enum gdb parameter - class TestEnumParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - show_doc = "Show the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - set_doc = "Set the state of the enum" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum is " + pvalue +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - return "The state of the enum has been set to " + self.value +PASS: gdb.python/py-parameter.exp: enum gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: enum gdb parameter - super (TestEnumParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_ENUM, ["one", "two"]) +PASS: gdb.python/py-parameter.exp: enum gdb parameter - self.value = "one" +PASS: gdb.python/py-parameter.exp: enum gdb parameter - test_enum_param = TestEnumParam ('print test-enum-param') +PASS: gdb.python/py-parameter.exp: enum gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Show parameter is initial value +PASS: gdb.python/py-parameter.exp: Set enum to two +PASS: gdb.python/py-parameter.exp: Show parameter is new value +PASS: gdb.python/py-parameter.exp: Test enum parameter value +PASS: gdb.python/py-parameter.exp: Set invalid enum parameter +PASS: gdb.python/py-parameter.exp: file gdb parameter - python +PASS: gdb.python/py-parameter.exp: file gdb parameter - class TestFileParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: file gdb parameter - """When set, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: file gdb parameter - show_doc = "Show the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - set_doc = "Set the name of the file" +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file is " + pvalue +PASS: gdb.python/py-parameter.exp: file gdb parameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: file gdb parameter - return "The name of the file has been changed to " + self.value +PASS: gdb.python/py-parameter.exp: file gdb parameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: file gdb parameter - super (TestFileParam, self).__init__ (name, gdb.COMMAND_FILES, gdb.PARAM_FILENAME) +PASS: gdb.python/py-parameter.exp: file gdb parameter - self.value = "foo.txt" +PASS: gdb.python/py-parameter.exp: file gdb parameter - test_file_param = TestFileParam ('test-file-param') +PASS: gdb.python/py-parameter.exp: file gdb parameter - end +PASS: gdb.python/py-parameter.exp: Test file parameter value +PASS: gdb.python/py-parameter.exp: Show initial file value +PASS: gdb.python/py-parameter.exp: Set new file parameter +PASS: gdb.python/py-parameter.exp: Show new file value +PASS: gdb.python/py-parameter.exp: Test new file parameter value +PASS: gdb.python/py-parameter.exp: set test-file-param +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestUndocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_show_string (self, pvalue): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "The state of the Test Parameter is " + pvalue +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def get_set_string (self): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "on" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - if (self.value == False): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - val = "off" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - return "Test Parameter has been set to " + val +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestUndocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_undoc_param = TestUndocParam ('print test-undoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestNodocParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestNodocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_nodoc_param = TestNodocParam ('print test-nodoc-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - python +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - class TestParam (gdb.Parameter): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - """When enabled, test param does something useful. When disabled, does nothing.""" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - show_doc = "State of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - set_doc = "Set the state of the Test Parameter" +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - def __init__ (self, name): +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN) +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - self.value = True +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - test_param = TestParam ('print test-param') +PASS: gdb.python/py-parameter.exp: Simple gdb booleanparameter - end +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Show parameter on +PASS: gdb.python/py-parameter.exp: Turn off parameter +PASS: gdb.python/py-parameter.exp: Show parameter off +PASS: gdb.python/py-parameter.exp: Test parameter value +PASS: gdb.python/py-parameter.exp: Test show help +PASS: gdb.python/py-parameter.exp: Test set help +PASS: gdb.python/py-parameter.exp: Test general help +Running ./gdb.python/py-pp-maint.exp ... +PASS: gdb.python/py-pp-maint.exp: b 77 +PASS: gdb.python/py-pp-maint.exp: continue +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt enabled #1 +PASS: gdb.python/py-pp-maint.exp: print ss enabled #1 +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: disable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer global .*function +PASS: gdb.python/py-pp-maint.exp: info pretty-printer .* pp-test +PASS: gdb.python/py-pp-maint.exp: print flt disabled +PASS: gdb.python/py-pp-maint.exp: print ss disabled +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global lookup_function_lookup_test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*ss.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.*s.* +PASS: gdb.python/py-pp-maint.exp: enable pretty-printer global pp-test;.* +PASS: gdb.python/py-pp-maint.exp: info pretty-printer +PASS: gdb.python/py-pp-maint.exp: print flt re-enabled +PASS: gdb.python/py-pp-maint.exp: print ss re-enabled +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | FLAG_3 +PASS: gdb.python/py-pp-maint.exp: print FLAG_1 | 8 +Running ./gdb.python/py-prettyprint.exp ... +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +PASS: gdb.python/py-prettyprint.exp: continue until exit +PASS: gdb.python/py-prettyprint.exp: set print pretty on +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: print ss +PASS: gdb.python/py-prettyprint.exp: print ssa[1] +PASS: gdb.python/py-prettyprint.exp: print ssa +PASS: gdb.python/py-prettyprint.exp: print arraystruct +PASS: gdb.python/py-prettyprint.exp: print cps +PASS: gdb.python/py-prettyprint.exp: print cpss +PASS: gdb.python/py-prettyprint.exp: print cpssa[0] +PASS: gdb.python/py-prettyprint.exp: print cpssa[1] +PASS: gdb.python/py-prettyprint.exp: print cpssa +PASS: gdb.python/py-prettyprint.exp: print sss +PASS: gdb.python/py-prettyprint.exp: print ref +PASS: gdb.python/py-prettyprint.exp: print derived +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns +PASS: gdb.python/py-prettyprint.exp: +PASS: gdb.python/py-prettyprint.exp: print ns2 +PASS: gdb.python/py-prettyprint.exp: print x +PASS: gdb.python/py-prettyprint.exp: print cstring +PASS: gdb.python/py-prettyprint.exp: print estring +PASS: gdb.python/py-prettyprint.exp: python pp_ls_encoding = 'UTF-8' +PASS: gdb.python/py-prettyprint.exp: print estring2 +PASS: gdb.python/py-prettyprint.exp: set python print-stack full +PASS: gdb.python/py-prettyprint.exp: print hint_error +PASS: gdb.python/py-prettyprint.exp: print c +PASS: gdb.python/py-prettyprint.exp: print nstype +PASS: gdb.python/py-prettyprint.exp: set print pretty off +PASS: gdb.python/py-prettyprint.exp: print nstype on one line +PASS: gdb.python/py-prettyprint.exp: continue until exit +PASS: gdb.python/py-prettyprint.exp: python exec (open ('py-prettyprint.py').read ()) +PASS: gdb.python/py-prettyprint.exp: continue to breakpoint: eval-break +PASS: gdb.python/py-prettyprint.exp: info locals +PASS: gdb.python/py-prettyprint.exp: b 351 +PASS: gdb.python/py-prettyprint.exp: continue +PASS: gdb.python/py-prettyprint.exp: print ss enabled #1 +PASS: gdb.python/py-prettyprint.exp: python disable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss disabled +PASS: gdb.python/py-prettyprint.exp: python enable_lookup_function () +PASS: gdb.python/py-prettyprint.exp: print ss enabled #2 +Running ./gdb.python/py-progspace.exp ... +PASS: gdb.python/py-progspace.exp: current progspace filename (None) +PASS: gdb.python/py-progspace.exp: python print (gdb.progspaces()) +PASS: gdb.python/py-progspace.exp: current progspace filename (py-progspace) +Running ./gdb.python/py-prompt.exp ... +Running ./gdb.python/py-section-script.exp ... +PASS: gdb.python/py-section-script.exp: set auto-load safe-path +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts py-section-script +PASS: gdb.python/py-section-script.exp: info auto-load python-scripts no-script-matches-this +PASS: gdb.python/py-section-script.exp: b 51 +PASS: gdb.python/py-section-script.exp: continue +PASS: gdb.python/py-section-script.exp: print ss +Running ./gdb.python/py-shared.exp ... +PASS: gdb.python/py-shared.exp: func1 address +PASS: gdb.python/py-shared.exp: Aquire func1 address +PASS: gdb.python/py-shared.exp: test func1 solib location +PASS: gdb.python/py-shared.exp: main address +PASS: gdb.python/py-shared.exp: Aquire main address +PASS: gdb.python/py-shared.exp: test main solib location +Running ./gdb.python/py-strfns.exp ... +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str2) +PASS: gdb.python/py-strfns.exp: p $_streq (str1, str3) +PASS: gdb.python/py-strfns.exp: p $_strlen (str1) +PASS: gdb.python/py-strfns.exp: p $_strlen (buf1) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf2, 4) +PASS: gdb.python/py-strfns.exp: p $_memeq (buf1, buf3, 4) +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "Help") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello") +PASS: gdb.python/py-strfns.exp: p $_regex (str1, "^Hello.$") +PASS: gdb.python/py-strfns.exp: condition $bpnum $_streq (arg, "Goodbye.") +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break func here. +PASS: gdb.python/py-strfns.exp: p arg +PASS: gdb.python/py-strfns.exp: condition $bpnum $_memeq (arg, buf3, 4) +PASS: gdb.python/py-strfns.exp: continue to breakpoint: Break bfunc here. +PASS: gdb.python/py-strfns.exp: p /d {char[4]} arg +PASS: gdb.python/py-strfns.exp: save a corefile +FAIL: gdb.python/py-strfns.exp: re-load generated corefile +Running ./gdb.python/py-symbol.exp ... +PASS: gdb.python/py-symbol.exp: Lookup main +PASS: gdb.python/py-symbol.exp: Test main_func.is_function +PASS: gdb.python/py-symbol.exp: Test lookup_global_symbol("junk") +PASS: gdb.python/py-symbol.exp: print value of main +PASS: gdb.python/py-symbol.exp: print line number of qq +PASS: gdb.python/py-symbol.exp: print value of qq +PASS: gdb.python/py-symbol.exp: print whether qq needs a frame +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symbol.exp: Test arg.is_variable +PASS: gdb.python/py-symbol.exp: Test arg.is_constant +PASS: gdb.python/py-symbol.exp: Test arg.is_argument +PASS: gdb.python/py-symbol.exp: Test arg.is_function +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test a.is_variable +PASS: gdb.python/py-symbol.exp: Test a.is_constant +PASS: gdb.python/py-symbol.exp: Test a.is_argument +PASS: gdb.python/py-symbol.exp: Test a.is_function +PASS: gdb.python/py-symbol.exp: Test a.addr_class +PASS: gdb.python/py-symbol.exp: try to print value of a without a frame +PASS: gdb.python/py-symbol.exp: print value of a +PASS: gdb.python/py-symbol.exp: print whether a needs a frame +PASS: gdb.python/py-symbol.exp: Test t.is_variable +PASS: gdb.python/py-symbol.exp: Test t.is_constant +PASS: gdb.python/py-symbol.exp: Test t.is_argument +PASS: gdb.python/py-symbol.exp: Test t.is_function +PASS: gdb.python/py-symbol.exp: Test t.addr_class +PASS: gdb.python/py-symbol.exp: Get type +PASS: gdb.python/py-symbol.exp: Get symtab +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break in class. +PASS: gdb.python/py-symbol.exp: Test func.is_variable +PASS: gdb.python/py-symbol.exp: Test func.is_constant +PASS: gdb.python/py-symbol.exp: Test func.is_argument +PASS: gdb.python/py-symbol.exp: Test func.is_function +PASS: gdb.python/py-symbol.exp: Test func.name +PASS: gdb.python/py-symbol.exp: Test func.print_name +PASS: gdb.python/py-symbol.exp: Test func.linkage_name +PASS: gdb.python/py-symbol.exp: Test func.addr_class +PASS: gdb.python/py-symbol.exp: continue to breakpoint: Break at end. +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol validity +PASS: gdb.python/py-symbol.exp: Test symbol destructor +Running ./gdb.python/py-symtab.exp ... +PASS: gdb.python/py-symtab.exp: continue to breakpoint: Block break here. +PASS: gdb.python/py-symtab.exp: Test symtab +PASS: gdb.python/py-symtab.exp: Test sal.pc +PASS: gdb.python/py-symtab.exp: Test sal.last +PASS: gdb.python/py-symtab.exp: Test sal.line +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.filename +PASS: gdb.python/py-symtab.exp: Test symtab.objfile +PASS: gdb.python/py-symtab.exp: Test symtab.fullname +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test qq in global symbols +PASS: gdb.python/py-symtab.exp: Test func in global symbols +PASS: gdb.python/py-symtab.exp: Test main in global symbols +PASS: gdb.python/py-symtab.exp: Test int in static symbols +PASS: gdb.python/py-symtab.exp: Test char in static symbols +PASS: gdb.python/py-symtab.exp: Test simple_struct in static symbols +PASS: gdb.python/py-symtab.exp: Test sal.is_valid +PASS: gdb.python/py-symtab.exp: Test symtab.is_valid() +PASS: gdb.python/py-symtab.exp: Test sal destructor +PASS: gdb.python/py-symtab.exp: Test symtab destructor +Running ./gdb.python/py-template.exp ... +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int & +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: volatile int * const * +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile +PASS: gdb.python/py-template.exp: print (foo) +PASS: gdb.python/py-template.exp: python foo = gdb.history(0) +PASS: gdb.python/py-template.exp: const int * volatile * const * volatile * +Running ./gdb.python/python.exp ... +PASS: gdb.python/python.exp: multi-line python command - python +PASS: gdb.python/python.exp: multi-line python command - print (23) +PASS: gdb.python/python.exp: multi-line python command - end +PASS: gdb.python/python.exp: show python command - define zzq +PASS: gdb.python/python.exp: show python command - python +PASS: gdb.python/python.exp: show python command - print (23) +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - end +PASS: gdb.python/python.exp: show python command - show user zzq +PASS: gdb.python/python.exp: indented multi-line python command - python +PASS: gdb.python/python.exp: indented multi-line python command - def foo (): +PASS: gdb.python/python.exp: indented multi-line python command - print ('hello, world!') +PASS: gdb.python/python.exp: indented multi-line python command - foo () +PASS: gdb.python/python.exp: indented multi-line python command - end +PASS: gdb.python/python.exp: source source2.py +PASS: gdb.python/python.exp: source -s source2.py +PASS: gdb.python/python.exp: python print (gdb.current_objfile()) +PASS: gdb.python/python.exp: python print (gdb.objfiles()) +PASS: gdb.python/python.exp: pythonX.Y/lib-dynload/*.so +PASS: gdb.python/python.exp: python x = gdb.execute('printf "%d", 23', to_string = True) +PASS: gdb.python/python.exp: python print (x) +PASS: gdb.python/python.exp: post event insertion - python +PASS: gdb.python/python.exp: post event insertion - someVal = 0 +PASS: gdb.python/python.exp: post event insertion - class Foo(object): +PASS: gdb.python/python.exp: post event insertion - def __call__(self): +PASS: gdb.python/python.exp: post event insertion - global someVal +PASS: gdb.python/python.exp: post event insertion - someVal += 1 +PASS: gdb.python/python.exp: post event insertion - gdb.post_event(Foo()) +PASS: gdb.python/python.exp: post event insertion - end +PASS: gdb.python/python.exp: test post event execution +PASS: gdb.python/python.exp: Test non callable class +PASS: gdb.python/python.exp: show height +PASS: gdb.python/python.exp: set height 10 +PASS: gdb.python/python.exp: verify pagination beforehand +PASS: gdb.python/python.exp: verify pagination beforehand: q +PASS: gdb.python/python.exp: gdb.execute does not page +PASS: gdb.python/python.exp: verify pagination afterwards +PASS: gdb.python/python.exp: verify pagination afterwards: q +PASS: gdb.python/python.exp: set height 0 +PASS: gdb.python/python.exp: collect help from uiout +PASS: gdb.python/python.exp: verify help to uiout +PASS: gdb.python/python.exp: Attempt to aquire thread with no inferior +PASS: gdb.python/python.exp: Ensure that no threads are returned +PASS: gdb.python/python.exp: register atexit function - python +PASS: gdb.python/python.exp: register atexit function - import atexit +PASS: gdb.python/python.exp: register atexit function - def printit(arg): +PASS: gdb.python/python.exp: register atexit function - print (arg) +PASS: gdb.python/python.exp: register atexit function - atexit.register(printit, 'good bye world') +PASS: gdb.python/python.exp: register atexit function - end +PASS: gdb.python/python.exp: atexit handling +PASS: gdb.python/python.exp: test decode_line no source named main +PASS: gdb.python/python.exp: test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line current location +PASS: gdb.python/python.exp: Test decode_line current locationn filename +PASS: gdb.python/python.exp: Test decode_line current location line number +PASS: gdb.python/python.exp: test decode_line python.c:26 +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line expression parse +PASS: gdb.python/python.exp: Test decode_line python.c:26 length +PASS: gdb.python/python.exp: Test decode_line python.c:26 filename +PASS: gdb.python/python.exp: Test decode_line python.c:26 line number +PASS: gdb.python/python.exp: test decode_line randomfunc +PASS: gdb.python/python.exp: test decode_line func1() +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 length +PASS: gdb.python/python.exp: Test decode_line func1 filename +PASS: gdb.python/python.exp: Test decode_line func1 line number +PASS: gdb.python/python.exp: test decode_line func1,func2 +PASS: gdb.python/python.exp: stop at comma in linespec +PASS: gdb.python/python.exp: Test stderr location +PASS: gdb.python/python.exp: Test stdout location +PASS: gdb.python/python.exp: Test default write +PASS: gdb.python/python.exp: Test stderr write +PASS: gdb.python/python.exp: Test stdout write +PASS: gdb.python/python.exp: Test stdlog write +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: prompt substitution - python +PASS: gdb.python/python.exp: prompt substitution - someCounter = 0 +PASS: gdb.python/python.exp: prompt substitution - def prompt(current): +PASS: gdb.python/python.exp: prompt substitution - global someCounter +PASS: gdb.python/python.exp: prompt substitution - if (current == "testfake "): +PASS: gdb.python/python.exp: prompt substitution - return None +PASS: gdb.python/python.exp: prompt substitution - someCounter = someCounter + 1 +PASS: gdb.python/python.exp: prompt substitution - return "py prompt " + str (someCounter) + " " +PASS: gdb.python/python.exp: prompt substitution - end +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def program_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - global pCounter +PASS: gdb.python/python.exp: prompt substitution readline - if (current == ">"): +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = pCounter + 1 +PASS: gdb.python/python.exp: prompt substitution readline - return "python line " + str (pCounter) + ": " +PASS: gdb.python/python.exp: prompt substitution readline - return None +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set prompt testfake +PASS: gdb.python/python.exp: show prompt shows guarded prompt +PASS: gdb.python/python.exp: set prompt blah overriden +PASS: gdb.python/python.exp: Delete old hook +PASS: gdb.python/python.exp: set default prompt +PASS: gdb.python/python.exp: set programming hook +PASS: gdb.python/python.exp: readline secondary are not substituted +PASS: gdb.python/python.exp: end programming +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - import gdb.command.prompt +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set basic extended prompt +PASS: gdb.python/python.exp: set extended prompt working directory +PASS: gdb.python/python.exp: set extended prompt parameter +PASS: gdb.python/python.exp: Test print-backtrace show setting. Default is message. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to full. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: Test print-backtrace show setting to none. +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: prompt substitution readline - python +PASS: gdb.python/python.exp: prompt substitution readline - pCounter = 0 +PASS: gdb.python/python.exp: prompt substitution readline - def error_prompt(current): +PASS: gdb.python/python.exp: prompt substitution readline - raise RuntimeError("Python exception called") +PASS: gdb.python/python.exp: prompt substitution readline - end +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Test print-backtrace set setting +PASS: gdb.python/python.exp: set hook +PASS: gdb.python/python.exp: set the hook to default +PASS: gdb.python/python.exp: Get line number of func2 call site +PASS: gdb.python/python.exp: Test find_pc_line at func2 call site +PASS: gdb.python/python.exp: Step into func2 +PASS: gdb.python/python.exp: Step out of func2 +PASS: gdb.python/python.exp: Test find_pc_line with resume address +Running ./gdb.python/py-type.exp ... +PASS: gdb.python/py-type.exp: lang_c: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_c: test_fields: c typedef field list +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_c: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_c: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_c: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_c: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_c: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_c: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_c: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_c: test_enum: Check enum fields items list +PASS: gdb.python/py-type.exp: lang_cpp: continue to breakpoint: break to inspect struct and array. +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: c++ typedef field list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (c) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from c.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (c) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field c name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check class field d name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (c.type == gdb.parse_and_eval('d').type.fields()[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get fields from st.type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field a name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check structure field b name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check that dir includes name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check number of fields (st.type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields lookup by name +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check fields items list +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name exists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check field name nonexists test +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check conversion to bool +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (len (st.type['a'].type)) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.has_key ('x')) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type.keys ()) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (st.type['a'].type['x']) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (not not st.type['a'].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python fields = ar.type.fields() +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: Check array field type +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to array with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print (ar[0].type == ar[0].type) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_1) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_1) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: print value (vec_data_2) +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: get value (vec_data_2) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec1 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with one argument +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: cast to vector with two arguments +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec2 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: set vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_fields: python print vec1 == vec3 +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: print value (d) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: get value (d) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: extract type fields from d +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check the number of fields +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[0]) +PASS: gdb.python/py-type.exp: lang_cpp: test_base_class: Check base class (fields[1]) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check correct tuple length +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged value: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: print value (ar) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get value (ar) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: get fields +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range low bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on ranged type: Check range high bound +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: print value (st) +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: get value (st) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_range: on unranged value: Check range for non ranged type. +PASS: gdb.python/py-type.exp: lang_cpp: get type of temvar +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(0)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(0), gdb.Type)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(1)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (isinstance(ttype.template_argument(1), gdb.Value)) +PASS: gdb.python/py-type.exp: lang_cpp: python print (ttype.template_argument(2)) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: print value (e) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: get value (e) from history +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: extract type fields from e +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of enum fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[0] name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field[1]name +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check the number of type fields +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v1) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum field lookup by name (v2) +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check num fields iteration over values +PASS: gdb.python/py-type.exp: lang_cpp: test_enum: Check enum fields items list +Running ./gdb.python/py-typeprint.exp ... +PASS: gdb.python/py-typeprint.exp: python exec (open ('py-typeprint.py').read ()) +PASS: gdb.python/py-typeprint.exp: basic test +PASS: gdb.python/py-typeprint.exp: raw test +PASS: gdb.python/py-typeprint.exp: disable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with disabled printer +PASS: gdb.python/py-typeprint.exp: info type-printers +PASS: gdb.python/py-typeprint.exp: enable type-printer string +PASS: gdb.python/py-typeprint.exp: whatis with enabled printer +PASS: gdb.python/py-typeprint.exp: whatis s +Running ./gdb.python/py-value-cc.exp ... +PASS: gdb.python/py-value-cc.exp: continue to breakpoint: Break here +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("a").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ref").referenced_value())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").dereference().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().type)) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().dereference())) +PASS: gdb.python/py-value-cc.exp: python print (str(gdb.parse_and_eval("int_ptr_ref").referenced_value().referenced_value())) +Running ./gdb.python/py-value.exp ... +PASS: gdb.python/py-value.exp: create boolean value +PASS: gdb.python/py-value.exp: create integer value +PASS: gdb.python/py-value.exp: create long value +PASS: gdb.python/py-value.exp: create double value +PASS: gdb.python/py-value.exp: create 8-bit string value +PASS: gdb.python/py-value.exp: print 8-bit string +PASS: gdb.python/py-value.exp: verify type of 8-bit string +PASS: gdb.python/py-value.exp: create unicode value +PASS: gdb.python/py-value.exp: print Unicode string +PASS: gdb.python/py-value.exp: verify type of unicode string +PASS: gdb.python/py-value.exp: Test address attribute in non-addressable value +PASS: gdb.python/py-value.exp: add two integer values +PASS: gdb.python/py-value.exp: verify type of integer add result +PASS: gdb.python/py-value.exp: add two double values +PASS: gdb.python/py-value.exp: subtract two integer values +PASS: gdb.python/py-value.exp: subtract two double values +PASS: gdb.python/py-value.exp: multiply two integer values +PASS: gdb.python/py-value.exp: multiply two double values +PASS: gdb.python/py-value.exp: divide two integer values +PASS: gdb.python/py-value.exp: divide two double values +PASS: gdb.python/py-value.exp: take remainder of two integer values +PASS: gdb.python/py-value.exp: integer value raised to the power of another integer value +PASS: gdb.python/py-value.exp: double value raised to the power of integer value +PASS: gdb.python/py-value.exp: negated integer value +PASS: gdb.python/py-value.exp: positive integer value +PASS: gdb.python/py-value.exp: negated double value +PASS: gdb.python/py-value.exp: positive double value +PASS: gdb.python/py-value.exp: absolute of integer value +PASS: gdb.python/py-value.exp: absolute of double value +PASS: gdb.python/py-value.exp: subtract integer value from python integer +PASS: gdb.python/py-value.exp: verify type of mixed integer subtraction result +PASS: gdb.python/py-value.exp: add double value with python float +PASS: gdb.python/py-value.exp: subtract python integer from integer value +PASS: gdb.python/py-value.exp: add python float with double value +PASS: gdb.python/py-value.exp: print evalue +PASS: gdb.python/py-value.exp: python evalue = gdb.history (0) +PASS: gdb.python/py-value.exp: python print (int (evalue)) +PASS: gdb.python/py-value.exp: add pointer value with python integer +PASS: gdb.python/py-value.exp: subtract python integer from pointer value +PASS: gdb.python/py-value.exp: subtract two pointer values +PASS: gdb.python/py-value.exp: catch error in python type conversion +PASS: gdb.python/py-value.exp: catch throw of GDB error +PASS: gdb.python/py-value.exp: define function to test booleans - python +PASS: gdb.python/py-value.exp: define function to test booleans - def test_bool (val): +PASS: gdb.python/py-value.exp: define function to test booleans - if val: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('yay') +PASS: gdb.python/py-value.exp: define function to test booleans - else: +PASS: gdb.python/py-value.exp: define function to test booleans - print ('nay') +PASS: gdb.python/py-value.exp: define function to test booleans - end +PASS: gdb.python/py-value.exp: check evaluation of true boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of false boolean value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of true integer value in expression +PASS: gdb.python/py-value.exp: check evaluation of false integer value in expression +PASS: gdb.python/py-value.exp: less than, equal +PASS: gdb.python/py-value.exp: less than, less +PASS: gdb.python/py-value.exp: less than, greater +PASS: gdb.python/py-value.exp: less than, None +PASS: gdb.python/py-value.exp: less or equal, equal +PASS: gdb.python/py-value.exp: less or equal, less +PASS: gdb.python/py-value.exp: less or equal, greater +PASS: gdb.python/py-value.exp: less or equal, None +PASS: gdb.python/py-value.exp: equality of gdb.Values +PASS: gdb.python/py-value.exp: inequality of gdb.Values +PASS: gdb.python/py-value.exp: equality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with Python value +PASS: gdb.python/py-value.exp: inequality of gdb.Value with None +PASS: gdb.python/py-value.exp: inequality, false +PASS: gdb.python/py-value.exp: inequality, true +PASS: gdb.python/py-value.exp: inequality, None +PASS: gdb.python/py-value.exp: greater than, equal +PASS: gdb.python/py-value.exp: greater than, less +PASS: gdb.python/py-value.exp: greater than, greater +PASS: gdb.python/py-value.exp: greater than, None +PASS: gdb.python/py-value.exp: greater or equal, equal +PASS: gdb.python/py-value.exp: greater or equal, less +PASS: gdb.python/py-value.exp: greater or equal, greater +PASS: gdb.python/py-value.exp: greater or equal, None +PASS: gdb.python/py-value.exp: py-value in file.filename +PASS: gdb.python/py-value.exp: python print (gdb.objfiles()[0].pretty_printers) +PASS: gdb.python/py-value.exp: python gdb.objfiles()[0].pretty_printers = 0 +PASS: gdb.python/py-value.exp: parse_and_eval constant test +PASS: gdb.python/py-value.exp: parse_and_eval simple expression test +PASS: gdb.python/py-value.exp: parse_and_eval type test +PASS: gdb.python/py-value.exp: Simple Python value dictionary - python +PASS: gdb.python/py-value.exp: Simple Python value dictionary - one = gdb.Value(1) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - two = gdb.Value(2) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - three = gdb.Value(3) +PASS: gdb.python/py-value.exp: Simple Python value dictionary - vdict = {one:"one str",two:"two str",three:"three str"} +PASS: gdb.python/py-value.exp: Simple Python value dictionary - end +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test dictionary hash +PASS: gdb.python/py-value.exp: Test inbuilt hash +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: access element inside struct using 8-bit string name +PASS: gdb.python/py-value.exp: access element inside struct using unicode name +PASS: gdb.python/py-value.exp: dereference value +PASS: gdb.python/py-value.exp: Test is_optimized_out attribute +PASS: gdb.python/py-value.exp: Test address attribute +PASS: gdb.python/py-value.exp: parse_and_eval with memory error +PASS: gdb.python/py-value.exp: python inval = gdb.parse_and_eval('*(int*)0') +PASS: gdb.python/py-value.exp: python print (inval.is_lazy) +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: memory error and lazy values +PASS: gdb.python/py-value.exp: python argc_lazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy = gdb.parse_and_eval('argc') +PASS: gdb.python/py-value.exp: python argc_notlazy.fetch_lazy() +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: python print (argc_notlazy.is_lazy) +PASS: gdb.python/py-value.exp: sanity check argc +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: set argc=2 +PASS: gdb.python/py-value.exp: python print (argc_notlazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy) +PASS: gdb.python/py-value.exp: python print (argc_lazy.is_lazy) +PASS: gdb.python/py-value.exp: print st +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string with no length +PASS: gdb.python/py-value.exp: Test string (length = -1) is all of the string +PASS: gdb.python/py-value.exp: python print (st.string (length = 6)) +PASS: gdb.python/py-value.exp: Test string (length = 0) is empty +PASS: gdb.python/py-value.exp: Test length is 0 +PASS: gdb.python/py-value.exp: print nullst +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: Test string to first null +PASS: gdb.python/py-value.exp: get string beyond null +PASS: gdb.python/py-value.exp: python print (repr(nullst)) +PASS: gdb.python/py-value.exp: p/x fp1 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp1 = fp1.dereference() +PASS: gdb.python/py-value.exp: python result = fp1() +PASS: gdb.python/py-value.exp: python print (result) +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp2 = fp2.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp2(10,20) +PASS: gdb.python/py-value.exp: python print (result2) +PASS: gdb.python/py-value.exp: p i +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python result3 = i() +PASS: gdb.python/py-value.exp: p/x fp2 +PASS: gdb.python/py-value.exp: get value from history +PASS: gdb.python/py-value.exp: python fp3 = fp3.dereference() +PASS: gdb.python/py-value.exp: python result2 = fp3(10) +PASS: gdb.python/py-value.exp: print sptr +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Aquire lazy string +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: Test type name equality +PASS: gdb.python/py-value.exp: print sn +PASS: gdb.python/py-value.exp: Get value from history +PASS: gdb.python/py-value.exp: Test lazy string +PASS: gdb.python/py-value.exp: Succesfully create a lazy string +PASS: gdb.python/py-value.exp: Test lazy string length +PASS: gdb.python/py-value.exp: Test lazy string address +PASS: gdb.python/py-value.exp: create PTR type +PASS: gdb.python/py-value.exp: kill the inferior +PASS: gdb.python/py-value.exp: Discard the symbols +PASS: gdb.python/py-value.exp: cast arg0 to PTR +PASS: gdb.python/py-value.exp: delete PTR type +PASS: gdb.python/py-value.exp: print value's type +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect pointer by reference +PASS: gdb.python/py-value.exp: Obtain address +PASS: gdb.python/py-value.exp: Obtains value from GDB +PASS: gdb.python/py-value.exp: Check pointer passed as reference +PASS: gdb.python/py-value.exp: python print (bool(gdb.parse_and_eval('base').dynamic_cast(gdb.lookup_type('Derived').pointer()))) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('base').dynamic_type) +PASS: gdb.python/py-value.exp: python print (gdb.parse_and_eval('5').dynamic_type) +PASS: gdb.python/py-value.exp: continue to breakpoint: break to inspect struct and union +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Create a value for subscript test +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Baseline print of a Python value +PASS: gdb.python/py-value.exp: Attempt to access a string with a subscript +PASS: gdb.python/py-value.exp: Build pointer to array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Access array via pointer with int subscript +PASS: gdb.python/py-value.exp: Access array via pointer with value subscript +PASS: gdb.python/py-value.exp: Attempt to access an integer with a subscript +PASS: gdb.python/py-value.exp: Build array +PASS: gdb.python/py-value.exp: +PASS: gdb.python/py-value.exp: Test multiple subscript +Running ./gdb.reverse/amd64-tailcall-reverse.exp ... +Running ./gdb.reverse/break-precsave.exp ... +Running ./gdb.reverse/break-reverse.exp ... +Running ./gdb.reverse/consecutive-precsave.exp ... +Running ./gdb.reverse/consecutive-reverse.exp ... +Running ./gdb.reverse/finish-precsave.exp ... +Running ./gdb.reverse/finish-reverse-bkpt.exp ... +Running ./gdb.reverse/finish-reverse.exp ... +Running ./gdb.reverse/i386-precsave.exp ... +Running ./gdb.reverse/i386-reverse.exp ... +Running ./gdb.reverse/i386-sse-reverse.exp ... +Running ./gdb.reverse/i387-env-reverse.exp ... +Running ./gdb.reverse/i387-stack-reverse.exp ... +Running ./gdb.reverse/machinestate.exp ... +Running ./gdb.reverse/machinestate-precsave.exp ... +Running ./gdb.reverse/next-reverse-bkpt-over-sr.exp ... +Running ./gdb.reverse/sigall-precsave.exp ... +Running ./gdb.reverse/sigall-reverse.exp ... +Running ./gdb.reverse/singlejmp-reverse.exp ... +Running ./gdb.reverse/solib-precsave.exp ... +Running ./gdb.reverse/solib-reverse.exp ... +Running ./gdb.reverse/step-precsave.exp ... +Running ./gdb.reverse/step-reverse.exp ... +Running ./gdb.reverse/until-precsave.exp ... +Running ./gdb.reverse/until-reverse.exp ... +Running ./gdb.reverse/watch-precsave.exp ... +Running ./gdb.reverse/watch-reverse.exp ... +Running ./gdb.server/ext-attach.exp ... +Running ./gdb.server/ext-run.exp ... +PASS: gdb.server/ext-run.exp: disconnect +PASS: gdb.server/ext-run.exp: set remote exec-file +PASS: gdb.server/ext-run.exp: continue to main +PASS: gdb.server/ext-run.exp: get process list +PASS: gdb.server/ext-run.exp: kill +PASS: gdb.server/ext-run.exp: load new file without any gdbserver inferior +PASS: gdb.server/ext-run.exp: monitor exit +Running ./gdb.server/file-transfer.exp ... +PASS: gdb.server/file-transfer.exp: disconnect +FAIL: gdb.server/file-transfer.exp: put binary file +FAIL: gdb.server/file-transfer.exp: get binary file +FAIL: gdb.server/file-transfer.exp: compare binary file +FAIL: gdb.server/file-transfer.exp: deleted binary file +FAIL: gdb.server/file-transfer.exp: put text file +FAIL: gdb.server/file-transfer.exp: get text file +FAIL: gdb.server/file-transfer.exp: compare text file +FAIL: gdb.server/file-transfer.exp: deleted text file +Running ./gdb.server/no-thread-db.exp ... +PASS: gdb.server/no-thread-db.exp: successfully compiled posix threads test case +PASS: gdb.server/no-thread-db.exp: disconnect +PASS: gdb.server/no-thread-db.exp: libthread-db is now unresolvable +PASS: gdb.server/no-thread-db.exp: continue to breakpoint: after tls assignment +PASS: gdb.server/no-thread-db.exp: print foo +Running ./gdb.server/server-exec-info.exp ... +PASS: gdb.server/server-exec-info.exp: file +PASS: gdb.server/server-exec-info.exp: set sysroot remote: +PASS: gdb.server/server-exec-info.exp: info files +Running ./gdb.server/server-kill.exp ... +PASS: gdb.server/server-kill.exp: disconnect +FAIL: gdb.server/server-kill.exp: tstatus +Running ./gdb.server/server-mon.exp ... +PASS: gdb.server/server-mon.exp: disconnect +PASS: gdb.server/server-mon.exp: monitor help +PASS: gdb.server/server-mon.exp: monitor +PASS: gdb.server/server-mon.exp: monitor set debug 1 +PASS: gdb.server/server-mon.exp: monitor set debug 0 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 1 +PASS: gdb.server/server-mon.exp: monitor set remote-debug 0 +Running ./gdb.server/server-run.exp ... +PASS: gdb.server/server-run.exp: disconnect +PASS: gdb.server/server-run.exp: loaded dynamic linker +PASS: gdb.server/server-run.exp: continue to main +Running ./gdb.server/solib-list.exp ... +Running ./gdb.stabs/exclfwd.exp ... +PASS: gdb.stabs/exclfwd.exp: ptype v1 +PASS: gdb.stabs/exclfwd.exp: ptype v2 +PASS: gdb.stabs/exclfwd.exp: ptype v3 +Running ./gdb.stabs/gdb11479.exp ... +PASS: gdb.stabs/gdb11479.exp: Set breakpoints forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 forced_stabs +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint forced_stabs +PASS: gdb.stabs/gdb11479.exp: Inspect t in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test forced_stabs +PASS: gdb.stabs/gdb11479.exp: Set breakpoints natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test2 natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Stop at first breakpoint natural_debug_format +PASS: gdb.stabs/gdb11479.exp: Inspect t in test natural_debug_format +PASS: gdb.stabs/gdb11479.exp: sizeof (e) in test natural_debug_format +Running ./gdb.stabs/weird.exp ... +PASS: gdb.stabs/weird.exp: weirdx.o read without error +PASS: gdb.stabs/weird.exp: stabs found +PASS: gdb.stabs/weird.exp: variable var0 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var0) +PASS: gdb.stabs/weird.exp: variable var1 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var1) +PASS: gdb.stabs/weird.exp: variable var2 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var2) +PASS: gdb.stabs/weird.exp: variable var3 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (var3) +PASS: gdb.stabs/weird.exp: variable attr32 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr32) +PASS: gdb.stabs/weird.exp: variable attr33 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr33) +PASS: gdb.stabs/weird.exp: variable attr35 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr35) +PASS: gdb.stabs/weird.exp: variable attr36 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr36) +PASS: gdb.stabs/weird.exp: variable attr37 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr37) +PASS: gdb.stabs/weird.exp: variable attr38 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr38) +PASS: gdb.stabs/weird.exp: variable attr39 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr39) +PASS: gdb.stabs/weird.exp: variable attr41 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr41) +PASS: gdb.stabs/weird.exp: variable attr42 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr42) +PASS: gdb.stabs/weird.exp: variable attr43 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr43) +PASS: gdb.stabs/weird.exp: variable attr44 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr44) +PASS: gdb.stabs/weird.exp: variable attr46 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr46) +PASS: gdb.stabs/weird.exp: variable attr47 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr47) +PASS: gdb.stabs/weird.exp: variable attr58 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr58) +PASS: gdb.stabs/weird.exp: variable attr59 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr59) +PASS: gdb.stabs/weird.exp: variable attr60 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr60) +PASS: gdb.stabs/weird.exp: variable attr61 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr61) +PASS: gdb.stabs/weird.exp: variable attr62 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr62) +PASS: gdb.stabs/weird.exp: variable attr63 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr63) +PASS: gdb.stabs/weird.exp: variable attr64 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr64) +PASS: gdb.stabs/weird.exp: variable attr65 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr65) +PASS: gdb.stabs/weird.exp: variable attr66 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr66) +PASS: gdb.stabs/weird.exp: variable attr67 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr67) +PASS: gdb.stabs/weird.exp: variable attr68 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr68) +PASS: gdb.stabs/weird.exp: variable attr69 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr69) +PASS: gdb.stabs/weird.exp: variable attr70 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr70) +PASS: gdb.stabs/weird.exp: variable attr71 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr71) +PASS: gdb.stabs/weird.exp: variable attr72 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr72) +PASS: gdb.stabs/weird.exp: variable attr73 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr73) +PASS: gdb.stabs/weird.exp: variable attr74 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr74) +PASS: gdb.stabs/weird.exp: variable attr75 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr75) +PASS: gdb.stabs/weird.exp: variable attr76 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr76) +PASS: gdb.stabs/weird.exp: variable attr77 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr77) +PASS: gdb.stabs/weird.exp: variable attr78 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr78) +PASS: gdb.stabs/weird.exp: variable attr79 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr79) +PASS: gdb.stabs/weird.exp: variable attr80 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr80) +PASS: gdb.stabs/weird.exp: variable attr81 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr81) +PASS: gdb.stabs/weird.exp: variable attr82 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr82) +PASS: gdb.stabs/weird.exp: variable attr83 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr83) +PASS: gdb.stabs/weird.exp: variable attr84 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr84) +PASS: gdb.stabs/weird.exp: variable attr85 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr85) +PASS: gdb.stabs/weird.exp: variable attr86 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr86) +PASS: gdb.stabs/weird.exp: variable attr87 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr87) +PASS: gdb.stabs/weird.exp: variable attr88 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr88) +PASS: gdb.stabs/weird.exp: variable attr89 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr89) +PASS: gdb.stabs/weird.exp: variable attr90 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr90) +PASS: gdb.stabs/weird.exp: variable attr91 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr91) +PASS: gdb.stabs/weird.exp: variable attr92 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr92) +PASS: gdb.stabs/weird.exp: variable attr93 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr93) +PASS: gdb.stabs/weird.exp: variable attr94 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr94) +PASS: gdb.stabs/weird.exp: variable attr95 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr95) +PASS: gdb.stabs/weird.exp: variable attr96 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr96) +PASS: gdb.stabs/weird.exp: variable attr97 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr97) +PASS: gdb.stabs/weird.exp: variable attr98 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr98) +PASS: gdb.stabs/weird.exp: variable attr99 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr99) +PASS: gdb.stabs/weird.exp: variable attr100 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr100) +PASS: gdb.stabs/weird.exp: variable attr101 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr101) +PASS: gdb.stabs/weird.exp: variable attr102 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr102) +PASS: gdb.stabs/weird.exp: variable attr103 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr103) +PASS: gdb.stabs/weird.exp: variable attr104 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr104) +PASS: gdb.stabs/weird.exp: variable attr105 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr105) +PASS: gdb.stabs/weird.exp: variable attr106 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr106) +PASS: gdb.stabs/weird.exp: variable attr107 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr107) +PASS: gdb.stabs/weird.exp: variable attr108 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr108) +PASS: gdb.stabs/weird.exp: variable attr109 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr109) +PASS: gdb.stabs/weird.exp: variable attr110 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr110) +PASS: gdb.stabs/weird.exp: variable attr111 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr111) +PASS: gdb.stabs/weird.exp: variable attr112 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr112) +PASS: gdb.stabs/weird.exp: variable attr113 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr113) +PASS: gdb.stabs/weird.exp: variable attr114 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr114) +PASS: gdb.stabs/weird.exp: variable attr115 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr115) +PASS: gdb.stabs/weird.exp: variable attr116 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr116) +PASS: gdb.stabs/weird.exp: variable attr117 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr117) +PASS: gdb.stabs/weird.exp: variable attr118 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr118) +PASS: gdb.stabs/weird.exp: variable attr119 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr119) +PASS: gdb.stabs/weird.exp: variable attr120 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr120) +PASS: gdb.stabs/weird.exp: variable attr121 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr121) +PASS: gdb.stabs/weird.exp: variable attr122 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr122) +PASS: gdb.stabs/weird.exp: variable attr123 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr123) +PASS: gdb.stabs/weird.exp: variable attr124 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr124) +PASS: gdb.stabs/weird.exp: variable attr125 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr125) +PASS: gdb.stabs/weird.exp: variable attr126 printed properly +PASS: gdb.stabs/weird.exp: print sizeof (attr126) +PASS: gdb.stabs/weird.exp: 'e' constant on non-enum type +PASS: gdb.stabs/weird.exp: whatis const69 +PASS: gdb.stabs/weird.exp: 'e' constant with embedded type +PASS: gdb.stabs/weird.exp: char constant +PASS: gdb.stabs/weird.exp: String constant 1 +PASS: gdb.stabs/weird.exp: String constant 2 +PASS: gdb.stabs/weird.exp: String constant 3 +PASS: gdb.stabs/weird.exp: String constant 4 +PASS: gdb.stabs/weird.exp: p bad_neg0 +PASS: gdb.stabs/weird.exp: ptype on inttype +PASS: gdb.stabs/weird.exp: unrecognized floating point type +PASS: gdb.stabs/weird.exp: print very big integer +PASS: gdb.stabs/weird.exp: whatis consth +PASS: gdb.stabs/weird.exp: whatis consth2 +XFAIL: gdb.stabs/weird.exp: print struct constant +PASS: gdb.stabs/weird.exp: print bad_type0 +PASS: gdb.stabs/weird.exp: print bad_type1 +XFAIL: gdb.stabs/weird.exp: array0 with strange index +XFAIL: gdb.stabs/weird.exp: array1 with strange index +PASS: gdb.stabs/weird.exp: whatis one_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis one_var test 2 +PASS: gdb.stabs/weird.exp: whatis two_var (known failure in gdb 4.10) +PASS: gdb.stabs/weird.exp: whatis two_var test 2 +XFAIL: gdb.stabs/weird.exp: whatis pointer_to_int_var +XFAIL: gdb.stabs/weird.exp: whatis intp_var +PASS: gdb.stabs/weird.exp: p common0var0 +XFAIL: gdb.stabs/weird.exp: p common0var1 +XFAIL: gdb.stabs/weird.exp: p common0var2 +Running ./gdb.threads/attach-into-signal.exp ... +Running ./gdb.threads/attach-stopped.exp ... +Running ./gdb.threads/bp_in_thread.exp ... +PASS: gdb.threads/bp_in_thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/bp_in_thread.exp: breakpoint on noreturn +PASS: gdb.threads/bp_in_thread.exp: run to noreturn +Running ./gdb.threads/clone-new-thread-event.exp ... +PASS: gdb.threads/clone-new-thread-event.exp: catch SIGUSR1 +Running ./gdb.threads/corethreads.exp ... +Running ./gdb.threads/create-fail.exp ... +PASS: gdb.threads/create-fail.exp: successfully compiled posix threads test case +PASS: gdb.threads/create-fail.exp: iteration 1: run till end +PASS: gdb.threads/create-fail.exp: iteration 2: run till end +PASS: gdb.threads/create-fail.exp: iteration 3: run till end +PASS: gdb.threads/create-fail.exp: iteration 4: run till end +PASS: gdb.threads/create-fail.exp: iteration 5: run till end +PASS: gdb.threads/create-fail.exp: iteration 6: run till end +PASS: gdb.threads/create-fail.exp: iteration 7: run till end +PASS: gdb.threads/create-fail.exp: iteration 8: run till end +PASS: gdb.threads/create-fail.exp: iteration 9: run till end +PASS: gdb.threads/create-fail.exp: iteration 10: run till end +Running ./gdb.threads/current-lwp-dead.exp ... +PASS: gdb.threads/current-lwp-dead.exp: continue to breakpoint: fn_return +Running ./gdb.threads/execl.exp ... +Running ./gdb.threads/fork-child-threads.exp ... +Running ./gdb.threads/fork-thread-pending.exp ... +Running ./gdb.threads/gcore-thread.exp ... +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: successfully compiled posix threads test case +PASS: gdb.threads/gcore-thread.exp: help gcore +PASS: gdb.threads/gcore-thread.exp: thread 1 is running +PASS: gdb.threads/gcore-thread.exp: thread 2 is running +PASS: gdb.threads/gcore-thread.exp: save a corefile +PASS: gdb.threads/gcore-thread.exp: clear __stack_user.next +PASS: gdb.threads/gcore-thread.exp: clear stack_used.next +PASS: gdb.threads/gcore-thread.exp: save a zeroed-threads corefile +FAIL: gdb.threads/gcore-thread.exp: corefile: re-load generated corefile (bad file format) +FAIL: gdb.threads/gcore-thread.exp: core0file: re-load generated corefile (bad file format) +Running ./gdb.threads/hand-call-in-threads.exp ... +PASS: gdb.threads/hand-call-in-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: breakpoint on hand_call +PASS: gdb.threads/hand-call-in-threads.exp: run to all_threads_running +PASS: gdb.threads/hand-call-in-threads.exp: enable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking on +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to make hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: set confirm off +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 1 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 2 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 3 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 4 +PASS: gdb.threads/hand-call-in-threads.exp: prepare to discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: dummy stack frame number, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: setting frame, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: discard hand call, thread 5 +PASS: gdb.threads/hand-call-in-threads.exp: all dummies popped +PASS: gdb.threads/hand-call-in-threads.exp: disable scheduler locking +PASS: gdb.threads/hand-call-in-threads.exp: show scheduler locking off +Running ./gdb.threads/ia64-sigill.exp ... +PASS: gdb.threads/ia64-sigill.exp: successfully compiled posix threads test case +PASS: gdb.threads/ia64-sigill.exp: info addr label +PASS: gdb.threads/ia64-sigill.exp: set $sigill_bpnum=$bpnum +PASS: gdb.threads/ia64-sigill.exp: set debug infrun 1 +PASS: gdb.threads/ia64-sigill.exp: continue +PASS: gdb.threads/ia64-sigill.exp: delete $sigill_bpnum +PASS: gdb.threads/ia64-sigill.exp: continue for the pending signal +Running ./gdb.threads/interrupted-hand-call.exp ... +PASS: gdb.threads/interrupted-hand-call.exp: successfully compiled posix threads test case +PASS: gdb.threads/interrupted-hand-call.exp: breakpoint on all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: run to all_threads_running +PASS: gdb.threads/interrupted-hand-call.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/interrupted-hand-call.exp: dummy stack frame present +PASS: gdb.threads/interrupted-hand-call.exp: finish hand-call +PASS: gdb.threads/interrupted-hand-call.exp: dummy frame popped +PASS: gdb.threads/interrupted-hand-call.exp: continue until exit +Running ./gdb.threads/killed.exp ... +PASS: gdb.threads/killed.exp: successfully compiled posix threads test case +PASS: gdb.threads/killed.exp: run program to completion +PASS: gdb.threads/killed.exp: GDB exits after multi-threaded program exits messily +Running ./gdb.threads/leader-exit.exp ... +PASS: gdb.threads/leader-exit.exp: successfully compiled posix threads test case +FAIL: gdb.threads/leader-exit.exp: continue to breakpoint: break-here (timeout) +FAIL: gdb.threads/leader-exit.exp: Single thread has been left (timeout) +Running ./gdb.threads/linux-dp.exp ... +PASS: gdb.threads/linux-dp.exp: successfully compiled posix threads test case +PASS: gdb.threads/linux-dp.exp: set print sevenbit-strings +PASS: gdb.threads/linux-dp.exp: info threads 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 0 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 0 +PASS: gdb.threads/linux-dp.exp: info threads after: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 1 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 1 +PASS: gdb.threads/linux-dp.exp: info threads after: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 2 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 2 +PASS: gdb.threads/linux-dp.exp: info threads after: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 3 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 3 +PASS: gdb.threads/linux-dp.exp: info threads after: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: about to create philosopher: 4 +UNSUPPORTED: gdb.threads/linux-dp.exp: create philosopher: 4 +PASS: gdb.threads/linux-dp.exp: info threads after: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/linux-dp.exp: info threads 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print +PASS: gdb.threads/linux-dp.exp: first thread-specific breakpoint hit +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 0 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 1 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 2 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 3 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 4 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 5 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 6 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 7 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 8 +PASS: gdb.threads/linux-dp.exp: continue to breakpoint: thread 5's print, pass: 9 +PASS: gdb.threads/linux-dp.exp: thread-specific breakpoint is thread-specific +PASS: gdb.threads/linux-dp.exp: selected thread: 1 +PASS: gdb.threads/linux-dp.exp: main is distinct: 1 +PASS: gdb.threads/linux-dp.exp: selected thread: 2 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 2 +PASS: gdb.threads/linux-dp.exp: selected thread: 3 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 3 +PASS: gdb.threads/linux-dp.exp: selected thread: 4 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 4 +PASS: gdb.threads/linux-dp.exp: selected thread: 5 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 5 +PASS: gdb.threads/linux-dp.exp: selected thread: 6 +PASS: gdb.threads/linux-dp.exp: philosopher is distinct: 6 +PASS: gdb.threads/linux-dp.exp: found an interesting thread +PASS: gdb.threads/linux-dp.exp: manager thread found (not found) when expected +Running ./gdb.threads/local-watch-wrong-thread.exp ... +Running ./gdb.threads/manythreads.exp ... +PASS: gdb.threads/manythreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/manythreads.exp: set print sevenbit-strings +PASS: gdb.threads/manythreads.exp: shell stty intr '^C' +PASS: gdb.threads/manythreads.exp: first continue +PASS: gdb.threads/manythreads.exp: stop threads 1 +PASS: gdb.threads/manythreads.exp: info threads +PASS: gdb.threads/manythreads.exp: give a name to the thread +PASS: gdb.threads/manythreads.exp: check thread name +PASS: gdb.threads/manythreads.exp: second continue +PASS: gdb.threads/manythreads.exp: check for duplicate SIGINT +PASS: gdb.threads/manythreads.exp: stop threads 2 +PASS: gdb.threads/manythreads.exp: GDB exits after stopping multithreaded program +Running ./gdb.threads/multi-create.exp ... +PASS: gdb.threads/multi-create.exp: successfully compiled posix threads test case +PASS: gdb.threads/multi-create.exp: continue to breakpoint 0 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 1 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 2 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 3 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 4 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 5 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 6 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 7 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 8 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 9 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 10 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 11 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 12 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 13 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 14 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 15 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 16 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 17 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 18 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 19 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 20 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 21 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 22 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 23 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 24 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 25 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 26 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 27 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 28 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 29 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 30 +PASS: gdb.threads/multi-create.exp: continue to breakpoint 31 +Running ./gdb.threads/non-ldr-exc-1.exp ... +Running ./gdb.threads/non-ldr-exc-2.exp ... +Running ./gdb.threads/non-ldr-exc-3.exp ... +Running ./gdb.threads/non-ldr-exc-4.exp ... +Running ./gdb.threads/no-unwaited-for-left.exp ... +PASS: gdb.threads/no-unwaited-for-left.exp: successfully compiled posix threads test case +PASS: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here +PASS: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for thread 2 +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when thread 2 exits (the program exited) +FAIL: gdb.threads/no-unwaited-for-left.exp: only main thread left, thread 2 terminated +PASS: gdb.threads/no-unwaited-for-left.exp: select main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: disable scheduler-locking, letting new thread start +FAIL: gdb.threads/no-unwaited-for-left.exp: continue to breakpoint: break-here-2 +FAIL: gdb.threads/no-unwaited-for-left.exp: enable scheduler-locking, for main thread +FAIL: gdb.threads/no-unwaited-for-left.exp: continue stops when the main thread exits (the program is no longer running) +FAIL: gdb.threads/no-unwaited-for-left.exp: only thread 3 left, main thread terminated +Running ./gdb.threads/pending-step.exp ... +PASS: gdb.threads/pending-step.exp: successfully compiled posix threads test case +PASS: gdb.threads/pending-step.exp: continue to breakpoint: continue to first breakpoint hit +PASS: gdb.threads/pending-step.exp: next in multiple threads with breakpoints +Running ./gdb.threads/print-threads.exp ... +PASS: gdb.threads/print-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/print-threads.exp: set print sevenbit-strings +PASS: gdb.threads/print-threads.exp: set width 0 +PASS: gdb.threads/print-threads.exp: shell stty intr '^C' +PASS: gdb.threads/print-threads.exp: break thread_function +PASS: gdb.threads/print-threads.exp: set var slow = 0 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (fast) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (fast) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (fast) +PASS: gdb.threads/print-threads.exp: break thread_function (2) +PASS: gdb.threads/print-threads.exp: set var slow = 1 +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow) +PASS: gdb.threads/print-threads.exp: break thread_function (3) +PASS: gdb.threads/print-threads.exp: set var slow = 1 (2) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 1 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 2 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 3 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 4 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: Hit thread_function breakpoint, 5 (slow with kill breakpoint) +PASS: gdb.threads/print-threads.exp: program exited normally +PASS: gdb.threads/print-threads.exp: all threads ran once (slow with kill breakpoint) +Running ./gdb.threads/pthread_cond_wait.exp ... +PASS: gdb.threads/pthread_cond_wait.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthread_cond_wait.exp: breakpoint on break_me +PASS: gdb.threads/pthread_cond_wait.exp: run to break_me +PASS: gdb.threads/pthread_cond_wait.exp: backtrace in blocked thread +Running ./gdb.threads/pthreads.exp ... +PASS: gdb.threads/pthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/pthreads.exp: set print sevenbit-strings +PASS: gdb.threads/pthreads.exp: set width 0 +PASS: gdb.threads/pthreads.exp: shell stty intr '^C' +PASS: gdb.threads/pthreads.exp: info threads +PASS: gdb.threads/pthreads.exp: break thread1 +PASS: gdb.threads/pthreads.exp: Continue to creation of first thread +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: break thread2 +PASS: gdb.threads/pthreads.exp: Continue to creation of second thread +PASS: gdb.threads/pthreads.exp: set var common_routine::hits=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after startup +PASS: gdb.threads/pthreads.exp: Continue with all threads running +PASS: gdb.threads/pthreads.exp: Stopped with a ^C +PASS: gdb.threads/pthreads.exp: bt +PASS: gdb.threads/pthreads.exp: set var common_routine::hits=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread1=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_thread2=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::from_main=0 +PASS: gdb.threads/pthreads.exp: set var common_routine::full_coverage=0 +PASS: gdb.threads/pthreads.exp: disable +PASS: gdb.threads/pthreads.exp: tbreak common_routine if hits >= 15 +PASS: gdb.threads/pthreads.exp: stopped before calling common_routine 15 times +PASS: gdb.threads/pthreads.exp: All threads running after continuing from ^C stop +PASS: gdb.threads/pthreads.exp: check backtrace from main thread +PASS: gdb.threads/pthreads.exp: check backtrace from thread 1 +PASS: gdb.threads/pthreads.exp: check backtrace from thread 2 +PASS: gdb.threads/pthreads.exp: apply backtrace command to all three threads +PASS: gdb.threads/pthreads.exp: set break at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: continue to bkpt at common_routine in thread 2 +PASS: gdb.threads/pthreads.exp: backtrace from thread 2 bkpt in common_routine +Running ./gdb.threads/schedlock.exp ... +PASS: gdb.threads/schedlock.exp: successfully compiled posix threads test case +PASS: gdb.threads/schedlock.exp: shell stty intr '^C' +PASS: gdb.threads/schedlock.exp: set print sevenbit-strings +PASS: gdb.threads/schedlock.exp: set width 0 +PASS: gdb.threads/schedlock.exp: scheduler locking set to none +PASS: gdb.threads/schedlock.exp: continue to breakpoint: all threads started +PASS: gdb.threads/schedlock.exp: listed args (1) +PASS: gdb.threads/schedlock.exp: continue (initial) +PASS: gdb.threads/schedlock.exp: stop all threads (initial) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (initial) +PASS: gdb.threads/schedlock.exp: listed args (2) +PASS: gdb.threads/schedlock.exp: all threads alive +PASS: gdb.threads/schedlock.exp: find current thread (1) +PASS: gdb.threads/schedlock.exp: set scheduler-locking off +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 0) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 1) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 2) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 3) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 4) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 5) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 6) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 7) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 8) +PASS: gdb.threads/schedlock.exp: step to increment (unlocked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step without lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (3) +PASS: gdb.threads/schedlock.exp: current thread stepped +PASS: gdb.threads/schedlock.exp: other threads ran - unlocked +PASS: gdb.threads/schedlock.exp: set scheduler-locking on +PASS: gdb.threads/schedlock.exp: continue (with lock) +PASS: gdb.threads/schedlock.exp: stop all threads (with lock) +PASS: gdb.threads/schedlock.exp: continue to breakpoint: return to loop (with lock) +PASS: gdb.threads/schedlock.exp: find current thread (3) +PASS: gdb.threads/schedlock.exp: continue with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (4) +PASS: gdb.threads/schedlock.exp: current thread ran +PASS: gdb.threads/schedlock.exp: other threads didn't run - locked +PASS: gdb.threads/schedlock.exp: step to increment (locked 0) +PASS: gdb.threads/schedlock.exp: step to increment (locked 1) +PASS: gdb.threads/schedlock.exp: step to increment (locked 2) +PASS: gdb.threads/schedlock.exp: step to increment (locked 3) +PASS: gdb.threads/schedlock.exp: step to increment (locked 4) +PASS: gdb.threads/schedlock.exp: step to increment (locked 5) +PASS: gdb.threads/schedlock.exp: step to increment (locked 6) +PASS: gdb.threads/schedlock.exp: step to increment (locked 7) +PASS: gdb.threads/schedlock.exp: step to increment (locked 8) +PASS: gdb.threads/schedlock.exp: step to increment (locked 9) +PASS: gdb.threads/schedlock.exp: find current thread (2) +PASS: gdb.threads/schedlock.exp: step with lock does not change thread +PASS: gdb.threads/schedlock.exp: listed args (5) +PASS: gdb.threads/schedlock.exp: current thread stepped locked +PASS: gdb.threads/schedlock.exp: other threads didn't run - step locked +Running ./gdb.threads/siginfo-threads.exp ... +PASS: gdb.threads/siginfo-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR1 stop print pass +PASS: gdb.threads/siginfo-threads.exp: handle SIGUSR2 stop print pass +PASS: gdb.threads/siginfo-threads.exp: get pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 0 +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 0 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 1 +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 1 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 2 +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 2 si_pid +PASS: gdb.threads/siginfo-threads.exp: catch signal 3 +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_signo +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_code is SI_TKILL +PASS: gdb.threads/siginfo-threads.exp: signal 3 si_pid +PASS: gdb.threads/siginfo-threads.exp: continue to breakpoint: break-at-exit +Running ./gdb.threads/sigstep-threads.exp ... +PASS: gdb.threads/sigstep-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigstep-threads.exp: handle SIGUSR1 nostop print pass +PASS: gdb.threads/sigstep-threads.exp: set scheduler-locking off +PASS: gdb.threads/sigstep-threads.exp: set $step1=$bpnum +PASS: gdb.threads/sigstep-threads.exp: continue to breakpoint: step-1 +PASS: gdb.threads/sigstep-threads.exp: disable $step1 +PASS: gdb.threads/sigstep-threads.exp: step +Running ./gdb.threads/sigthread.exp ... +PASS: gdb.threads/sigthread.exp: successfully compiled posix threads test case +PASS: gdb.threads/sigthread.exp: handle SIGUSR1 nostop noprint pass +PASS: gdb.threads/sigthread.exp: handle SIGUSR2 nostop noprint pass +PASS: gdb.threads/sigthread.exp: continue +PASS: gdb.threads/sigthread.exp: stop with control-c +Running ./gdb.threads/staticthreads.exp ... +PASS: gdb.threads/staticthreads.exp: successfully compiled posix threads test case +PASS: gdb.threads/staticthreads.exp: set print sevenbit-strings +PASS: gdb.threads/staticthreads.exp: break sem_post +PASS: gdb.threads/staticthreads.exp: Continue to main's call of sem_post +PASS: gdb.threads/staticthreads.exp: rerun to main +PASS: gdb.threads/staticthreads.exp: handle SIG32 nostop noprint pass +PASS: gdb.threads/staticthreads.exp: handle SIG32 helps +PASS: gdb.threads/staticthreads.exp: info threads +PASS: gdb.threads/staticthreads.exp: GDB exits with static thread program +Running ./gdb.threads/switch-threads.exp ... +PASS: gdb.threads/switch-threads.exp: successfully compiled posix threads test case +PASS: gdb.threads/switch-threads.exp: continue to breakpoint: continue to thread_func +PASS: gdb.threads/switch-threads.exp: next +Running ./gdb.threads/threadapply.exp ... +PASS: gdb.threads/threadapply.exp: successfully compiled posix threads test case +PASS: gdb.threads/threadapply.exp: b 62 +PASS: gdb.threads/threadapply.exp: continue +PASS: gdb.threads/threadapply.exp: macro details +PASS: gdb.threads/threadapply.exp: defining macro +PASS: gdb.threads/threadapply.exp: set backtrace limit 3 +PASS: gdb.threads/threadapply.exp: thread apply all backthread +PASS: gdb.threads/threadapply.exp: step to the thread_function +PASS: gdb.threads/threadapply.exp: go up in the stack frame +PASS: gdb.threads/threadapply.exp: run a simple print command on all threads +PASS: gdb.threads/threadapply.exp: go down and check selected frame +Running ./gdb.threads/thread_check.exp ... +PASS: gdb.threads/thread_check.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread_check.exp: breakpoint at tf +PASS: gdb.threads/thread_check.exp: continue to tf +PASS: gdb.threads/thread_check.exp: backtrace from thread function +Running ./gdb.threads/thread_events.exp ... +Running ./gdb.threads/thread-execl.exp ... +Running ./gdb.threads/thread-find.exp ... +PASS: gdb.threads/thread-find.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-find.exp: set print sevenbit-strings +PASS: gdb.threads/thread-find.exp: continue to breakpoint: main thread's sleep +PASS: gdb.threads/thread-find.exp: info threads +PASS: gdb.threads/thread-find.exp: name thread 1 +PASS: gdb.threads/thread-find.exp: name thread 2 +PASS: gdb.threads/thread-find.exp: name thread 3 +PASS: gdb.threads/thread-find.exp: name thread 4 +PASS: gdb.threads/thread-find.exp: name thread 5 +PASS: gdb.threads/thread-find.exp: name thread 6 +PASS: gdb.threads/thread-find.exp: collect thread id +PASS: gdb.threads/thread-find.exp: got thread ids +PASS: gdb.threads/thread-find.exp: collect process id +PASS: gdb.threads/thread-find.exp: collect lwp id +PASS: gdb.threads/thread-find.exp: find thread name 6 +PASS: gdb.threads/thread-find.exp: find thread name 5 +PASS: gdb.threads/thread-find.exp: find thread name 4 +PASS: gdb.threads/thread-find.exp: find thread name 3 +PASS: gdb.threads/thread-find.exp: find thread name 2 +PASS: gdb.threads/thread-find.exp: find thread name 1 +PASS: gdb.threads/thread-find.exp: find thread id 6 +PASS: gdb.threads/thread-find.exp: find thread id 5 +PASS: gdb.threads/thread-find.exp: find thread id 4 +PASS: gdb.threads/thread-find.exp: find thread id 3 +PASS: gdb.threads/thread-find.exp: find thread id 2 +PASS: gdb.threads/thread-find.exp: find thread id 1 +PASS: gdb.threads/thread-find.exp: no thread +PASS: gdb.threads/thread-find.exp: test regular exp +PASS: gdb.threads/thread-find.exp: info threads 2 4 6 +PASS: gdb.threads/thread-find.exp: info threads 3-5 +PASS: gdb.threads/thread-find.exp: test inverted range +PASS: gdb.threads/thread-find.exp: info threads 3-3 +PASS: gdb.threads/thread-find.exp: info thread foo +PASS: gdb.threads/thread-find.exp: info thread foo -1 +Running ./gdb.threads/thread-specific.exp ... +PASS: gdb.threads/thread-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-specific.exp: set print sevenbit-strings +PASS: gdb.threads/thread-specific.exp: set width 0 +PASS: gdb.threads/thread-specific.exp: thread var when not running +PASS: gdb.threads/thread-specific.exp: continue to breakpoint: all threads started +PASS: gdb.threads/thread-specific.exp: get threads list +PASS: gdb.threads/thread-specific.exp: thread var in main +PASS: gdb.threads/thread-specific.exp: breakpoint 59 main thread +PASS: gdb.threads/thread-specific.exp: continue to thread-specific breakpoint +PASS: gdb.threads/thread-specific.exp: found breakpoint for thread number +PASS: gdb.threads/thread-specific.exp: thread var at break +Running ./gdb.threads/thread-unwindonsignal.exp ... +PASS: gdb.threads/thread-unwindonsignal.exp: successfully compiled posix threads test case +PASS: gdb.threads/thread-unwindonsignal.exp: breakpoint on all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: run to all_threads_running +PASS: gdb.threads/thread-unwindonsignal.exp: setting unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: showing unwindonsignal +PASS: gdb.threads/thread-unwindonsignal.exp: hand-call interrupted by signal in another thread +PASS: gdb.threads/thread-unwindonsignal.exp: dummy stack frame present +PASS: gdb.threads/thread-unwindonsignal.exp: wrong thread not unwound +PASS: gdb.threads/thread-unwindonsignal.exp: finish hand-call +PASS: gdb.threads/thread-unwindonsignal.exp: dummy frame popped +PASS: gdb.threads/thread-unwindonsignal.exp: continue until exit +Running ./gdb.threads/threxit-hop-specific.exp ... +PASS: gdb.threads/threxit-hop-specific.exp: successfully compiled posix threads test case +PASS: gdb.threads/threxit-hop-specific.exp: continue to thread start +PASS: gdb.threads/threxit-hop-specific.exp: set thread specific breakpoint +PASS: gdb.threads/threxit-hop-specific.exp: get past the thread specific breakpoint +Running ./gdb.threads/tls.exp ... +PASS: gdb.threads/tls.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls.exp: set breakpoint at all threads +PASS: gdb.threads/tls.exp: set breakpoint at synch point +PASS: gdb.threads/tls.exp: set breakpoint at exit +PASS: gdb.threads/tls.exp: continue to first thread: get to thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at first th +PASS: gdb.threads/tls.exp: first thread print me +PASS: gdb.threads/tls.exp: first thread local storage +PASS: gdb.threads/tls.exp: first another thread local storage +PASS: gdb.threads/tls.exp: first info address a_thread_local +PASS: gdb.threads/tls.exp: first info address another_thread_local +PASS: gdb.threads/tls.exp: continue to second thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at second th +PASS: gdb.threads/tls.exp: second thread print me +PASS: gdb.threads/tls.exp: second thread local storage +PASS: gdb.threads/tls.exp: second another thread local storage +PASS: gdb.threads/tls.exp: second info address a_thread_local +PASS: gdb.threads/tls.exp: second info address another_thread_local +PASS: gdb.threads/tls.exp: continue to third thread +PASS: gdb.threads/tls.exp: at least one th in spin while stopped at third th +PASS: gdb.threads/tls.exp: third thread print me +PASS: gdb.threads/tls.exp: third thread local storage +PASS: gdb.threads/tls.exp: third another thread local storage +PASS: gdb.threads/tls.exp: third info address a_thread_local +PASS: gdb.threads/tls.exp: third info address another_thread_local +PASS: gdb.threads/tls.exp: continue to synch point +PASS: gdb.threads/tls.exp: get number of threads +PASS: gdb.threads/tls.exp: selected thread: 1 +PASS: gdb.threads/tls.exp: backtrace of thread number 1 not relevant +PASS: gdb.threads/tls.exp: selected thread: 2 +PASS: gdb.threads/tls.exp: backtrace of thread number 2 in spin +PASS: gdb.threads/tls.exp: selected thread: 3 +PASS: gdb.threads/tls.exp: backtrace of thread number 3 in spin +PASS: gdb.threads/tls.exp: selected thread: 4 +PASS: gdb.threads/tls.exp: backtrace of thread number 4 in spin +PASS: gdb.threads/tls.exp: selected thread: 4 +PASS: gdb.threads/tls.exp: thread 4 up +PASS: gdb.threads/tls.exp: 4 thread print me +PASS: gdb.threads/tls.exp: 4 thread local storage +PASS: gdb.threads/tls.exp: 4 another thread local storage +PASS: gdb.threads/tls.exp: 4 info address a_thread_local +PASS: gdb.threads/tls.exp: 4 info address another_thread_local +PASS: gdb.threads/tls.exp: selected thread: 2 +PASS: gdb.threads/tls.exp: thread 2 up +PASS: gdb.threads/tls.exp: 2 thread print me +PASS: gdb.threads/tls.exp: 2 thread local storage +PASS: gdb.threads/tls.exp: 2 another thread local storage +PASS: gdb.threads/tls.exp: 2 info address a_thread_local +PASS: gdb.threads/tls.exp: 2 info address another_thread_local +PASS: gdb.threads/tls.exp: selected thread: 3 +PASS: gdb.threads/tls.exp: thread 3 up +PASS: gdb.threads/tls.exp: 3 thread print me +PASS: gdb.threads/tls.exp: 3 thread local storage +PASS: gdb.threads/tls.exp: 3 another thread local storage +PASS: gdb.threads/tls.exp: 3 info address a_thread_local +PASS: gdb.threads/tls.exp: 3 info address another_thread_local +PASS: gdb.threads/tls.exp: threads exited +PASS: gdb.threads/tls.exp: Expect only base thread at end +PASS: gdb.threads/tls.exp: info address a_global +PASS: gdb.threads/tls.exp: info address me +PASS: gdb.threads/tls.exp: p a_thread_local +FAIL: gdb.threads/tls.exp: p file2_thread_local +PASS: gdb.threads/tls.exp: info address file2_thread_local +PASS: gdb.threads/tls.exp: p a_thread_local second time +PASS: gdb.threads/tls.exp: info address a_thread_local +Running ./gdb.threads/tls-nodebug.exp ... +PASS: gdb.threads/tls-nodebug.exp: successfully compiled posix threads test case +FAIL: gdb.threads/tls-nodebug.exp: thread local storage +Running ./gdb.threads/tls-shared.exp ... +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-shared.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-shared.exp: print thread local storage variable +PASS: gdb.threads/tls-shared.exp: ptype of thread local storage variable +PASS: gdb.threads/tls-shared.exp: print storage info for thread local storage variable +PASS: gdb.threads/tls-shared.exp: break at and of main +PASS: gdb.threads/tls-shared.exp: continue to break +PASS: gdb.threads/tls-shared.exp: print result +Running ./gdb.threads/tls-var.exp ... +PASS: gdb.threads/tls-var.exp: successfully compiled posix threads test case +PASS: gdb.threads/tls-var.exp: whatis tls_var +PASS: gdb.threads/tls-var.exp: print tls_var +Running ./gdb.threads/watchpoint-fork.exp ... +KFAIL: gdb.threads/watchpoint-fork.exp: gdbserver does not support debugging across fork (PRMS: remote/13584) +Running ./gdb.threads/watchthreads2.exp ... +Running ./gdb.threads/watchthreads.exp ... +Running ./gdb.threads/watchthreads-reorder.exp ... +Running ./gdb.trace/actions.exp ... +PASS: gdb.trace/actions.exp: 5.1a: set three tracepoints, no actions +PASS: gdb.trace/actions.exp: 5.1b: set actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.1c: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.1d: set actions for second tracepoint +PASS: gdb.trace/actions.exp: 5.1e: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.2a: set actions for last (default) tracepoint +PASS: gdb.trace/actions.exp: 5.2b: verify actions set for second tracepoint +PASS: gdb.trace/actions.exp: 5.3a: reset actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.3b: verify actions set for first tracepoint +PASS: gdb.trace/actions.exp: 5.4: 'end' command out of context +PASS: gdb.trace/actions.exp: 5.5a: set empty actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.5c: verify NO actions for first tracepoint +PASS: gdb.trace/actions.exp: 5.6: actions for invalid tracepoint number +PASS: gdb.trace/actions.exp: 5.7: invalid action +PASS: gdb.trace/actions.exp: 5.8a: help actions +PASS: gdb.trace/actions.exp: 5.8b: help collect +PASS: gdb.trace/actions.exp: 5.8c: help while-stepping +PASS: gdb.trace/actions.exp: 5.8d: help end +PASS: gdb.trace/actions.exp: 5.9a: set default-collect +PASS: gdb.trace/actions.exp: 5.9b: show default-collect +PASS: gdb.trace/actions.exp: 5.9c: set default-collect +PASS: gdb.trace/actions.exp: Create a trace state variable +PASS: gdb.trace/actions.exp: 5.10a: set teval action for first tracepoint +PASS: gdb.trace/actions.exp: 5.10a: set teval action for second tracepoint +PASS: gdb.trace/actions.exp: 5.10a: verify teval actions set for two tracepoints +Running ./gdb.trace/ax.exp ... +PASS: gdb.trace/ax.exp: maint agent 12 +PASS: gdb.trace/ax.exp: maint agent gdb_char_test +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent &gdb_long_test < &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval 12 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_char_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[12] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_arr_test[gdb_short_test] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.s +PASS: gdb.trace/ax.exp: maint agent-eval gdb_struct1_test.arr[gdb_struct1_test.c] +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->l +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test->bfield +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test + gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test - gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test * gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test / gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_structp_test + 1 +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test == gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test != gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test < gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test <= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test > gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval gdb_long_test >= gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test == &gdb_short_test +PASS: gdb.trace/ax.exp: maint agent-eval &gdb_long_test < &gdb_short_test +Running ./gdb.trace/backtrace.exp ... +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect regs +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect regs, args, and locals +PASS: gdb.trace/backtrace.exp: 8.6: setup TP to collect stack mem cast expr +PASS: gdb.trace/backtrace.exp: run trace experiment +PASS: gdb.trace/backtrace.exp: init: make sure not debugging any trace frame +PASS: gdb.trace/backtrace.exp: 8.6: find start frame +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 1 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 2 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 4 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 5 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 6 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 7 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 2, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 9 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 10 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 11 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 12 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 3, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 14 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 8.6: find frame 15 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect nothing +PASS: gdb.trace/backtrace.exp: 8.6: find frame 16 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect regs +PASS: gdb.trace/backtrace.exp: 8.6: find frame 17 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 4, collect args and locals +PASS: gdb.trace/backtrace.exp: 8.6: find frame 19 +PASS: gdb.trace/backtrace.exp: 8.6: Backtrace, depth == 1, collect stack mem expr +PASS: gdb.trace/backtrace.exp: 1.13: trace in recursion: depth not equal to 3 +Running ./gdb.trace/change-loc.exp ... +PASS: gdb.trace/change-loc.exp: 1 trace: delete break 1 +PASS: gdb.trace/change-loc.exp: 1 trace: next +PASS: gdb.trace/change-loc.exp: 1 trace: set tracepoint on main +PASS: gdb.trace/change-loc.exp: 1 trace: breakpoint on marker +PASS: gdb.trace/change-loc.exp: 1 trace: tstart +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 1 +PASS: gdb.trace/change-loc.exp: 1 trace: set tracepoint on set_tracepoint +PASS: gdb.trace/change-loc.exp: 1 trace: set action for tracepoint +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with two locations +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 2 +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with three locations +PASS: gdb.trace/change-loc.exp: 1 trace: continue to marker 3 +FAIL: gdb.trace/change-loc.exp: 1 trace: tracepoint with two locations (unload) +PASS: gdb.trace/change-loc.exp: 1 trace: tstop +FAIL: gdb.trace/change-loc.exp: 1 trace: tfind frame 0 +PASS: gdb.trace/change-loc.exp: 1 trace: tfind +PASS: gdb.trace/change-loc.exp: 2 trace: set pending tracepoint +PASS: gdb.trace/change-loc.exp: 2 trace: set action for tracepoint +PASS: gdb.trace/change-loc.exp: 2 trace: single pending tracepoint info (without symbols) +PASS: gdb.trace/change-loc.exp: 2 trace: tracepoint with one location +PASS: gdb.trace/change-loc.exp: 2 trace: run to main +PASS: gdb.trace/change-loc.exp: 2 trace: delete break 2 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with two locations +PASS: gdb.trace/change-loc.exp: 2 trace: breakpoint on marker +PASS: gdb.trace/change-loc.exp: 2 trace: tstart +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 1 +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 2 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with three locations +PASS: gdb.trace/change-loc.exp: 2 trace: continue to marker 3 +FAIL: gdb.trace/change-loc.exp: 2 trace: tracepoint with two locations (unload) +PASS: gdb.trace/change-loc.exp: 2 trace: tstop +PASS: gdb.trace/change-loc.exp: 2 trace: tfind frame 0 +FAIL: gdb.trace/change-loc.exp: 2 trace: tfind frame 1 +FAIL: gdb.trace/change-loc.exp: 2 trace: tfind frame 2 +PASS: gdb.trace/change-loc.exp: 2 trace: tfind +ERROR: (DejaGnu) proc "else\{" does not exist. +Running ./gdb.xml/tdesc-arch.exp ... +PASS: gdb.xml/tdesc-arch.exp: read valid architectures +PASS: gdb.xml/tdesc-arch.exp: read default architecture +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (first architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (first architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (second architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (second architecture) +PASS: gdb.xml/tdesc-arch.exp: set tdesc filename tdesc-arch.xml (invalid architecture) +PASS: gdb.xml/tdesc-arch.exp: show architecture (invalid architecture) +Running ./gdb.xml/tdesc-errors.exp ... +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-bogus.xml +PASS: gdb.xml/tdesc-errors.exp: set tdesc filename gdb.xml/tdesc-unknown.xml +Running ./gdb.xml/tdesc-regs.exp ... +PASS: gdb.xml/tdesc-regs.exp: set tdesc file single-reg.xml +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from extra-regs.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +PASS: gdb.xml/tdesc-regs.exp: ptype $uintreg +PASS: gdb.xml/tdesc-regs.exp: ptype $vecreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg +PASS: gdb.xml/tdesc-regs.exp: ptype $unionreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg +PASS: gdb.xml/tdesc-regs.exp: ptype $structreg.v4 +PASS: gdb.xml/tdesc-regs.exp: ptype $bitfields +PASS: gdb.xml/tdesc-regs.exp: set tdesc filename regs.xml - from core-only.xml +PASS: gdb.xml/tdesc-regs.exp: ptype $extrareg +Running ./gdb.xml/tdesc-xinclude.exp ... +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/includes.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/bad-include.xml +PASS: gdb.xml/tdesc-xinclude.exp: set tdesc filename gdb.xml/loop.xml + + === gdb Summary === + +# of expected passes 17760 +# of unexpected failures 276 +# of unexpected successes 1 +# of expected failures 32 +# of known failures 44 +# of untested testcases 50 +# of unresolved testcases 13 +# of unsupported tests 106 +/var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../../gdb/gdb version 7.6.1 -nw -nx -data-directory /var/tmp/portage/cross-x86_64-cros-linux-gnu/gdb-7.6.1/work/gdb-7.6.1/gdb/testsuite/../data-directory + diff --git a/deprecated/dejagnu/gdb_dejagnu.py b/deprecated/dejagnu/gdb_dejagnu.py new file mode 100755 index 00000000..91fa51fd --- /dev/null +++ b/deprecated/dejagnu/gdb_dejagnu.py @@ -0,0 +1,357 @@ +#!/usr/bin/python2 + +# Copyright (c) 2013 The Chromium OS Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. +"""The gdb dejagnu test wrapper.""" +import optparse +import os +from os import path +import re +import shutil +import stat +import sys +import tempfile +import time + +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import misc + +from run_dejagnu import TryAcquireMachine + +_VALID_TEST_RESULTS = ['FAIL', 'UNRESOLVED', 'XPASS', 'ERROR', 'UNSUPPORTED', + 'PASS'] + + +def ProcessArguments(argv): + """Processing/validating script arguments.""" + parser = optparse.OptionParser(description=( + 'Launches gdb dejagnu test in chroot for chromeos toolchain, compares ' + 'the test result with a repository baseline and prints out the result.'), + usage='run_dejagnu options') + parser.add_option('-c', + '--chromeos_root', + dest='chromeos_root', + help='Required. Specify chromeos root') + parser.add_option('-m', + '--mount', + dest='mount', + help=('Specify gdb source to mount instead of "auto". ' + 'Under "auto" mode, which is the default - gdb is ' + 'checked out and built automatically at default ' + 'directories. Under "mount" mode ' + '- the gdb_source is set to "$chromeos_' + 'root/chroot/usr/local/toolchain_root/gdb", which is ' + 'the mount point for this option value.')) + parser.add_option('-b', + '--board', + dest='board', + help=('Required. Specify board.')) + parser.add_option('-r', + '--remote', + dest='remote', + help=('Required. Specify addresses/names of the board, ' + 'seperate each address/name using comma(\',\').')) + parser.add_option('--cleanup', + dest='cleanup', + default=None, + help=('Optional. Values to this option could be ' + '\'chroot\' (delete chroot) and ' + '\'chromeos\' (delete the whole chromeos tree).')) + + options, args = parser.parse_args(argv) + + if not options.chromeos_root: + raise SyntaxError('Missing argument for --chromeos_root.') + if not options.remote: + raise SyntaxError('Missing argument for --remote.') + if not options.board: + raise SyntaxError('Missing argument for --board.') + if options.cleanup == 'mount' and not options.mount: + raise SyntaxError('--cleanup=\'mount\' not valid unless --mount is given.') + if options.cleanup and not (options.cleanup == 'mount' or + options.cleanup == 'chroot' or + options.cleanup == 'chromeos'): + raise SyntaxError('Invalid option value for --cleanup') + + return options + + +class DejagnuExecuter(object): + """The class wrapper for dejagnu test executer.""" + + def __init__(self, base_dir, source_dir, chromeos_root, remote, board, + cleanup): + self._l = logger.GetLogger() + self._chromeos_root = chromeos_root + self._chromeos_chroot = path.join(chromeos_root, 'chroot') + + self._remote = remote + self._board = board + ## Compute target from board + self._target = misc.GetCtargetFromBoard(board, chromeos_root) + if not self._target: + raise RuntimeError('Unsupported board "%s"' % board) + self._executer = command_executer.GetCommandExecuter() + self._base_dir = base_dir + self._tmp_abs = None + self._cleanup = cleanup + self._sshflag = ('-o StrictHostKeyChecking=no ' + '-o CheckHostIP=no ' + + '-o UserKnownHostsFile=$(mktemp) ') + + if source_dir: + self._source_dir = source_dir + self._mount_flag = 'USE="mounted_sources"' + self.MountSource() + else: + self._source_dir = None + self._mount_flag = '' + + def SetupTestingDir(self): + self._tmp_abs = tempfile.mkdtemp( + prefix='dejagnu_', + dir=path.join(self._chromeos_chroot, 'tmp')) + self._tmp = self._tmp_abs[len(self._chromeos_chroot):] + self._tmp_testing_rsa = path.join(self._tmp, 'testing_rsa') + self._tmp_testing_rsa_abs = path.join(self._tmp_abs, 'testing_rsa') + + def PrepareTestingRsaKeys(self): + if not path.isfile(self._tmp_testing_rsa_abs): + shutil.copy( + path.join(self._chromeos_root, + 'src/scripts/mod_for_test_scripts/ssh_keys/testing_rsa'), + self._tmp_testing_rsa_abs) + os.chmod(self._tmp_testing_rsa_abs, stat.S_IRUSR) + + def PrepareTestFiles(self): + """Prepare site.exp and board exp files.""" + # Create the boards directory. + os.mkdir('%s/boards' % self._tmp_abs) + + # Generate the chromeos.exp file. + with open('%s/boards/gdb.exp.in' % self._base_dir, 'r') as template_file: + content = template_file.read() + + substitutions = dict({ + '__boardname__': self._board, + '__board_hostname__': self._remote, + '__tmp_testing_rsa__': self._tmp_testing_rsa, + '__tmp_dir__': self._tmp + }) + for pat, sub in substitutions.items(): + content = content.replace(pat, sub) + + board_file_name = '%s/boards/%s.exp' % (self._tmp_abs, self._board) + with open(board_file_name, 'w') as board_file: + board_file.write(content) + + # Generate the site file + with open('%s/site.exp' % self._tmp_abs, 'w') as site_file: + site_file.write('set target_list "%s"\n' % self._board) + + with open('%s/boards/gdbserver.sh.in' % self._base_dir, 'r') \ + as template_file: + content = template_file.read() + substitutions = dict({ + '__board_hostname__': self._remote, + '__tmp_testing_rsa__': self._tmp_testing_rsa, + '__tmp_dir__': self._tmp + }) + for pat, sub in substitutions.items(): + content = content.replace(pat, sub) + + gdbserver_file_name = '%s/boards/gdbserver.sh' % (self._tmp_abs) + with open(gdbserver_file_name, 'w') as board_file: + board_file.write(content) + + st = os.stat(gdbserver_file_name) + os.chmod(gdbserver_file_name, st.st_mode | stat.S_IXGRP | stat.S_IXUSR) + + def PrepareGdb(self): + self.PrepareGdbDefault() + + def PrepareGdbDefault(self): + ret = self._executer.ChrootRunCommandWOutput( + self._chromeos_root, 'equery w cross-%s/gdb' % self._target)[1] + ret = path.basename(ret.strip()) + + matcher = re.match(r'(.*).ebuild', ret) + if matcher: + gdb_reversion = matcher.group(1) + else: + raise RuntimeError('Failed to get gdb reversion.') + gdb_version = gdb_reversion.split('-r')[0] + gdb_portage_dir = '/var/tmp/portage/cross-%s/%s/work' % (self._target, + gdb_reversion) + self._gdb_source_dir = path.join(gdb_portage_dir, gdb_version) + + ret = self._executer.ChrootRunCommand(self._chromeos_root, ( + 'sudo %s ebuild $(equery w cross-%s/gdb) clean compile' % ( + self._mount_flag, self._target))) + if ret: + raise RuntimeError('ebuild gdb failed.') + + def PrepareGdbserver(self): + self.PrepareGdbserverDefault() + + def PrepareGdbserverDefault(self): + cmd = ('setup_board --board {0}; ' + '{1} emerge-{0} gdb'.format(self._board, self._mount_flag)) + ret = self._executer.ChrootRunCommand(self._chromeos_root, + cmd, + print_to_console=True) + if ret: + raise RuntimeError('ebuild gdbserver failed.') + + cmd = ('scp -i {0} {1} ' + '/build/{2}/usr/bin/gdbserver root@{3}:/usr/local/bin/'.format( + self._tmp_testing_rsa, self._sshflag, self._board, self._remote)) + ret = self._executer.ChrootRunCommand(self._chromeos_root, + cmd, + print_to_console=True) + if ret: + raise RuntimeError('copy gdbserver failed.') + + if self._mount_flag: + self.MountSource(unmount=False) + + def Cleanup(self): + if not self._cleanup: + return + + if self._cleanup == 'chroot' or self._cleanup == 'chromeos': + self._l.LogOutput('[Cleanup]: Deleting chroot inside \'{0}\''.format( + self._chromeos_root)) + command = 'cd %s; cros_sdk --delete' % self._chromeos_root + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to delete chroot.') + # Delete .cache - crosbug.com/34956 + command = 'sudo rm -fr %s' % os.path.join(self._chromeos_root, '.cache') + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to delete \'.cache\'.') + + if self._cleanup == 'chromeos': + self._l.LogOutput('[Cleanup]: Deleting chromeos tree \'{0}\' ...'.format( + self._chromeos_root)) + command = 'rm -fr {0}'.format(self._chromeos_root) + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to remove chromeos tree.') + + def MakeCheck(self): + cmd = ('ssh -i {0} {1} root@{2} "reboot && exit"' + .format(self._tmp_testing_rsa, self._sshflag, self._remote)) + self._executer.ChrootRunCommand(self._chromeos_root, cmd) + time.sleep(40) + + cmd = ('ssh -i {0} {1} root@{2} ' + '"iptables -A INPUT -p tcp --dport 1234 -j ACCEPT"'.format( + self._tmp_testing_rsa, self._sshflag, self._remote)) + self._executer.ChrootRunCommand(self._chromeos_root, cmd) + + cmd = ('cd %s ; ' + 'DEJAGNU=%s make check' % (path.join(self._gdb_source_dir, 'gdb'), + path.join(self._tmp, 'site.exp'))) + ret = self._executer.ChrootRunCommand(self._chromeos_root, cmd) + if ret: + raise RuntimeError('Make check failed.') + + # This method ensures necessary mount points before executing chroot comamnd. + def MountSource(self, unmount=False): + script = os.path.join(self._base_dir, 'build_tc.py') + if unmount: + mount = '-u' + else: + mount = '-m' + cmd = ('python {0} --chromeos_root={1} ' + '--gdb_dir={2} --board={3} {4}'.format(script, self._chromeos_root, + self._source_dir, self._board, + mount)) + rv = self._executer.RunCommand(cmd) + if rv: + raise RuntimeError('Mount source failed.') + + def ResultValidate(self): + self.PrepareResult() + result = [] + for key, value in self.base_result.items(): + if 'PASS' not in value: + continue + if key not in self.test_result: + continue + test_result = self.test_result[key] + if 'PASS' not in test_result: + result.append(key) + return result + + def PrepareResult(self): + test_output = os.path.join(self._gdb_source_dir, 'gdb', 'testsuite', + 'gdb.sum') + test_output = misc.GetOutsideChrootPath(self._chromeos_root, test_output) + base_output = os.path.join(self._base_dir, 'gdb_baseline', self._target) + + self.test_result = self.ParseResult(test_output) + self.base_result = self.ParseResult(base_output) + + def ParseResult(self, gdb_sum): + result = {} + multi_keys = {} + with open(gdb_sum) as input_sum: + for line in input_sum: + line = line.strip() + r = line.split(':', 1) + if r[0] in _VALID_TEST_RESULTS: + key = r[1] + if r[1] in result: + if r[1] in multi_keys: + multi_keys[r[1]] += 1 + else: + multi_keys[r[1]] = 2 + key = r[1] + '_____{0}_____'.format(multi_keys[r[1]]) + result[key] = r[0] + return result + + +def Main(argv): + opts = ProcessArguments(argv) + available_machine = TryAcquireMachine(opts.remote) + executer = DejagnuExecuter( + misc.GetRoot(argv[0])[0], opts.mount, opts.chromeos_root, + available_machine._name, opts.board, opts.cleanup) + # Return value is a 3- or 4-element tuple + # element#1 - exit code + # element#2 - stdout + # element#3 - stderr + # element#4 - exception infor + # Some other scripts need these detailed information. + ret = (1, '', '') + try: + executer.SetupTestingDir() + executer.PrepareTestingRsaKeys() + executer.PrepareTestFiles() + executer.PrepareGdb() + executer.PrepareGdbserver() + executer.MakeCheck() + result = executer.ResultValidate() + print result + if result: + ret = (1, result, '') + else: + ret = (0, '', '') + + except Exception as e: + # At least log the exception on console. + print e + # The #4 element encodes the runtime exception. + ret = (1, '', '', 'Exception happened during execution: \n' + str(e)) + finally: + executer.Cleanup() + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv)[0] + sys.exit(retval) diff --git a/deprecated/dejagnu/run_dejagnu.py b/deprecated/dejagnu/run_dejagnu.py new file mode 100755 index 00000000..7b6e6fa3 --- /dev/null +++ b/deprecated/dejagnu/run_dejagnu.py @@ -0,0 +1,418 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Tool script for auto dejagnu.""" + +__author__ = 'shenhan@google.com (Han Shen)' + +import getpass +import optparse +import os +from os import path +import re +import shutil +import stat +import sys +import tempfile +import time + +import lock_machine +import tc_enter_chroot +from cros_utils import command_executer +from cros_utils import constants +from cros_utils import logger +from cros_utils import misc + + +def ProcessArguments(argv): + """Processing/validating script arguments.""" + parser = optparse.OptionParser(description=( + 'Launches gcc dejagnu test in chroot for chromeos toolchain, compares ' + 'the test result with a repository baseline and prints out the result.'), + usage='run_dejagnu options') + parser.add_option('-c', + '--chromeos_root', + dest='chromeos_root', + help='Required. Specify chromeos root') + parser.add_option('-m', + '--mount', + dest='mount', + help=('Specify gcc source to mount instead of "auto". ' + 'Under "auto" mode, which is the default - gcc is ' + 'checked out and built automatically at default ' + 'directories. Under "mount" mode ' + '- the gcc_source is set to "$chromeos_' + 'root/chroot/usr/local/toolchain_root/gcc", which is ' + 'the mount point for this option value, the ' + 'gcc-build-dir then is computed as ' + '"${gcc_source_dir}-build-${ctarget}". In this mode, ' + 'a complete gcc build must be performed in the ' + 'computed gcc-build-dir beforehand.')) + parser.add_option('-b', + '--board', + dest='board', + help=('Required. Specify board.')) + parser.add_option('-r', + '--remote', + dest='remote', + help=('Required. Specify addresses/names of the board, ' + 'seperate each address/name using comma(\',\').')) + parser.add_option('-f', + '--flags', + dest='flags', + help='Optional. Extra run test flags to pass to dejagnu.') + parser.add_option('-k', + '--keep', + dest='keep_intermediate_files', + action='store_true', + default=False, + help=('Optional. Default to false. Do not remove dejagnu ' + 'intermediate files after test run.')) + parser.add_option('--cleanup', + dest='cleanup', + default=None, + help=('Optional. Values to this option could be ' + '\'mount\' (unmount gcc source and ' + 'directory directory, ' + 'only valid when --mount is given), ' + '\'chroot\' (delete chroot) and ' + '\'chromeos\' (delete the whole chromeos tree).')) + parser.add_option('-t', + '--tools', + dest='tools', + default='gcc,g++', + help=('Optional. Specify which tools to check, using ' + '","(comma) as separator. A typical value would be ' + '"g++" so that only g++ tests are performed. ' + 'Defaults to "gcc,g++".')) + + options, args = parser.parse_args(argv) + + if not options.chromeos_root: + raise SyntaxError('Missing argument for --chromeos_root.') + if not options.remote: + raise SyntaxError('Missing argument for --remote.') + if not options.board: + raise SyntaxError('Missing argument for --board.') + if options.cleanup == 'mount' and not options.mount: + raise SyntaxError('--cleanup=\'mount\' not valid unless --mount is given.') + if options.cleanup and not ( + options.cleanup == 'mount' or \ + options.cleanup == 'chroot' or options.cleanup == 'chromeos'): + raise ValueError('Invalid option value for --cleanup') + if options.cleanup and options.keep_intermediate_files: + raise SyntaxError('Only one of --keep and --cleanup could be given.') + + return options + + +class DejagnuExecuter(object): + """The class wrapper for dejagnu test executer.""" + + def __init__(self, base_dir, mount, chromeos_root, remote, board, flags, + keep_intermediate_files, tools, cleanup): + self._l = logger.GetLogger() + self._chromeos_root = chromeos_root + self._chromeos_chroot = path.join(chromeos_root, 'chroot') + if mount: + self._gcc_source_dir_to_mount = mount + self._gcc_source_dir = path.join(constants.MOUNTED_TOOLCHAIN_ROOT, 'gcc') + else: + self._gcc_source_dir = None + + self._remote = remote + self._board = board + ## Compute target from board + self._target = misc.GetCtargetFromBoard(board, chromeos_root) + if not self._target: + raise ValueError('Unsupported board "%s"' % board) + self._executer = command_executer.GetCommandExecuter() + self._flags = flags or '' + self._base_dir = base_dir + self._tmp_abs = None + self._keep_intermediate_files = keep_intermediate_files + self._tools = tools.split(',') + self._cleanup = cleanup + + def SetupTestingDir(self): + self._tmp_abs = tempfile.mkdtemp( + prefix='dejagnu_', + dir=path.join(self._chromeos_chroot, 'tmp')) + self._tmp = self._tmp_abs[len(self._chromeos_chroot):] + self._tmp_testing_rsa = path.join(self._tmp, 'testing_rsa') + self._tmp_testing_rsa_abs = path.join(self._tmp_abs, 'testing_rsa') + + def MakeCheckString(self): + return ' '.join(['check-{0}'.format(t) for t in self._tools if t]) + + def CleanupIntermediateFiles(self): + if self._tmp_abs and path.isdir(self._tmp_abs): + if self._keep_intermediate_files: + self._l.LogOutput( + 'Your intermediate dejagnu files are kept, you can re-run ' + 'inside chroot the command:') + self._l.LogOutput( + ' DEJAGNU={0} make -C {1} {2} RUNTESTFLAGS="--target_board={3} {4}"' \ + .format(path.join(self._tmp, 'site.exp'), self._gcc_build_dir, + self.MakeCheckString(), self._board, self._flags)) + else: + self._l.LogOutput('[Cleanup] - Removing temp dir - {0}'.format( + self._tmp_abs)) + shutil.rmtree(self._tmp_abs) + + def Cleanup(self): + if not self._cleanup: + return + + # Optionally cleanup mounted diretory, chroot and chromeos tree. + if self._cleanup == 'mount' or self._cleanup == 'chroot' or \ + self._cleanup == 'chromeos': + # No exceptions are allowed from this method. + try: + self._l.LogOutput('[Cleanup] - Unmounting directories ...') + self.MountGccSourceAndBuildDir(unmount=True) + except: + print 'Warning: failed to unmount gcc source/build directory.' + + if self._cleanup == 'chroot' or self._cleanup == 'chromeos': + self._l.LogOutput('[Cleanup]: Deleting chroot inside \'{0}\''.format( + self._chromeos_root)) + command = 'cd %s; cros_sdk --delete' % self._chromeos_root + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to delete chroot.') + # Delete .cache - crosbug.com/34956 + command = 'sudo rm -fr %s' % os.path.join(self._chromeos_root, '.cache') + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to delete \'.cache\'.') + + if self._cleanup == 'chromeos': + self._l.LogOutput('[Cleanup]: Deleting chromeos tree \'{0}\' ...'.format( + self._chromeos_root)) + command = 'rm -fr {0}'.format(self._chromeos_root) + rv = self._executer.RunCommand(command) + if rv: + self._l.LogWarning('Warning - failed to remove chromeos tree.') + + def PrepareTestingRsaKeys(self): + if not path.isfile(self._tmp_testing_rsa_abs): + shutil.copy( + path.join(self._chromeos_root, + 'src/scripts/mod_for_test_scripts/ssh_keys/testing_rsa'), + self._tmp_testing_rsa_abs) + os.chmod(self._tmp_testing_rsa_abs, stat.S_IRUSR) + + def PrepareTestFiles(self): + """Prepare site.exp and board exp files.""" + # Create the boards directory. + os.mkdir('%s/boards' % self._tmp_abs) + + # Generate the chromeos.exp file. + with open('%s/chromeos.exp.in' % self._base_dir, 'r') as template_file: + content = template_file.read() + substitutions = dict({ + '__boardname__': self._board, + '__board_hostname__': self._remote, + '__tmp_testing_rsa__': self._tmp_testing_rsa, + '__tmp_dir__': self._tmp + }) + for pat, sub in substitutions.items(): + content = content.replace(pat, sub) + + board_file_name = '%s/boards/%s.exp' % (self._tmp_abs, self._board) + with open(board_file_name, 'w') as board_file: + board_file.write(content) + + # Generate the site file + with open('%s/site.exp' % self._tmp_abs, 'w') as site_file: + site_file.write('set target_list "%s"\n' % self._board) + + def PrepareGcc(self): + if self._gcc_source_dir: + self.PrepareGccFromCustomizedPath() + else: + self.PrepareGccDefault() + self._l.LogOutput('Gcc source dir - {0}'.format(self._gcc_source_dir)) + self._l.LogOutput('Gcc build dir - {0}'.format(self._gcc_top_build_dir)) + + def PrepareGccFromCustomizedPath(self): + """Prepare gcc source, build directory from mounted source.""" + # We have these source directories - + # _gcc_source_dir + # e.g. '/usr/local/toolchain_root/gcc' + # _gcc_source_dir_abs + # e.g. '/somewhere/chromeos.live/chroot/usr/local/toolchain_root/gcc' + # _gcc_source_dir_to_mount + # e.g. '/somewhere/gcc' + self._gcc_source_dir_abs = path.join(self._chromeos_chroot, + self._gcc_source_dir.lstrip('/')) + if not path.isdir(self._gcc_source_dir_abs) and \ + self._executer.RunCommand( + 'sudo mkdir -p {0}'.format(self._gcc_source_dir_abs)): + raise RuntimeError("Failed to create \'{0}\' inside chroot.".format( + self._gcc_source_dir)) + if not (path.isdir(self._gcc_source_dir_to_mount) and + path.isdir(path.join(self._gcc_source_dir_to_mount, 'gcc'))): + raise RuntimeError('{0} is not a valid gcc source tree.'.format( + self._gcc_source_dir_to_mount)) + + # We have these build directories - + # _gcc_top_build_dir + # e.g. '/usr/local/toolchain_root/gcc-build-x86_64-cros-linux-gnu' + # _gcc_top_build_dir_abs + # e.g. '/somewhere/chromeos.live/chroo/tusr/local/toolchain_root/ + # gcc-build-x86_64-cros-linux-gnu' + # _gcc_build_dir + # e.g. '/usr/local/toolchain_root/gcc-build-x86_64-cros-linux-gnu/gcc' + # _gcc_build_dir_to_mount + # e.g. '/somewhere/gcc-build-x86_64-cros-linux-gnu' + self._gcc_top_build_dir = '{0}-build-{1}'.format( + self._gcc_source_dir.rstrip('/'), self._target) + self._gcc_build_dir = path.join(self._gcc_top_build_dir, 'gcc') + self._gcc_build_dir_to_mount = '{0}-build-{1}'.format( + self._gcc_source_dir_to_mount, self._target) + self._gcc_top_build_dir_abs = path.join(self._chromeos_chroot, + self._gcc_top_build_dir.lstrip('/')) + if not path.isdir(self._gcc_top_build_dir_abs) and \ + self._executer.RunCommand( + 'sudo mkdir -p {0}'.format(self._gcc_top_build_dir_abs)): + raise RuntimeError('Failed to create \'{0}\' inside chroot.'.format( + self._gcc_top_build_dir)) + if not (path.isdir(self._gcc_build_dir_to_mount) and path.join( + self._gcc_build_dir_to_mount, 'gcc')): + raise RuntimeError('{0} is not a valid gcc build tree.'.format( + self._gcc_build_dir_to_mount)) + + # All check passed. Now mount gcc source and build directories. + self.MountGccSourceAndBuildDir() + + def PrepareGccDefault(self): + """Auto emerging gcc for building purpose only.""" + ret = self._executer.ChrootRunCommandWOutput( + self._chromeos_root, 'equery w cross-%s/gcc' % self._target)[1] + ret = path.basename(ret.strip()) + # ret is expected to be something like 'gcc-4.6.2-r11.ebuild' or + # 'gcc-9999.ebuild' parse it. + matcher = re.match('((.*)-r\d+).ebuild', ret) + if matcher: + gccrevision, gccversion = matcher.group(1, 2) + elif ret == 'gcc-9999.ebuild': + gccrevision = 'gcc-9999' + gccversion = 'gcc-9999' + else: + raise RuntimeError('Failed to get gcc version.') + + gcc_portage_dir = '/var/tmp/portage/cross-%s/%s/work' % (self._target, + gccrevision) + self._gcc_source_dir = path.join(gcc_portage_dir, gccversion) + self._gcc_top_build_dir = (gcc_portage_dir + '/%s-build-%s') % ( + gccversion, self._target) + self._gcc_build_dir = path.join(self._gcc_top_build_dir, 'gcc') + gcc_build_dir_abs = path.join(self._chromeos_root, 'chroot', + self._gcc_build_dir.lstrip('/')) + if not path.isdir(gcc_build_dir_abs): + ret = self._executer.ChrootRunCommand(self._chromeos_root, ( + 'ebuild $(equery w cross-%s/gcc) clean prepare compile' % ( + self._target))) + if ret: + raise RuntimeError('ebuild gcc failed.') + + def MakeCheck(self): + self.MountGccSourceAndBuildDir() + cmd = ('cd %s ; ' + 'DEJAGNU=%s make %s RUNTESTFLAGS="--target_board=%s %s"' % + (self._gcc_build_dir, path.join(self._tmp, 'site.exp'), + self.MakeCheckString(), self._board, self._flags)) + self._executer.ChrootRunCommand(self._chromeos_root, cmd) + + def ValidateFailures(self): + validate_failures_py = path.join( + self._gcc_source_dir, + 'contrib/testsuite-management/validate_failures.py') + cmd = 'cd {0} ; {1} --build_dir={0}'.format(self._gcc_top_build_dir, + validate_failures_py) + self.MountGccSourceAndBuildDir() + ret = self._executer.ChrootRunCommandWOutput(self._chromeos_root, cmd) + if ret[0] != 0: + self._l.LogWarning('*** validate_failures.py exited with non-zero code,' + 'please run it manually inside chroot - \n' + ' ' + cmd) + return ret + + # This method ensures necessary mount points before executing chroot comamnd. + def MountGccSourceAndBuildDir(self, unmount=False): + mount_points = [tc_enter_chroot.MountPoint(self._gcc_source_dir_to_mount, + self._gcc_source_dir_abs, + getpass.getuser(), 'ro'), + tc_enter_chroot.MountPoint(self._gcc_build_dir_to_mount, + self._gcc_top_build_dir_abs, + getpass.getuser(), 'rw')] + for mp in mount_points: + if unmount: + if mp.UnMount(): + raise RuntimeError('Failed to unmount {0}'.format(mp.mount_dir)) + else: + self._l.LogOutput('{0} unmounted successfully.'.format(mp.mount_dir)) + elif mp.DoMount(): + raise RuntimeError( + 'Failed to mount {0} onto {1}'.format(mp.external_dir, + mp.mount_dir)) + else: + self._l.LogOutput('{0} mounted successfully.'.format(mp.mount_dir)) + +# The end of class DejagnuExecuter + + +def TryAcquireMachine(remotes): + available_machine = None + for r in remotes.split(','): + machine = lock_machine.Machine(r) + if machine.TryLock(timeout=300, exclusive=True): + available_machine = machine + break + else: + logger.GetLogger().LogWarning( + '*** Failed to lock machine \'{0}\'.'.format(r)) + if not available_machine: + raise RuntimeError("Failed to acquire one machine from \'{0}\'.".format( + remotes)) + return available_machine + + +def Main(argv): + opts = ProcessArguments(argv) + available_machine = TryAcquireMachine(opts.remote) + executer = DejagnuExecuter( + misc.GetRoot(argv[0])[0], opts.mount, opts.chromeos_root, + available_machine._name, opts.board, opts.flags, + opts.keep_intermediate_files, opts.tools, opts.cleanup) + # Return value is a 3- or 4-element tuple + # element#1 - exit code + # element#2 - stdout + # element#3 - stderr + # element#4 - exception infor + # Some other scripts need these detailed information. + ret = (1, '', '') + try: + executer.SetupTestingDir() + executer.PrepareTestingRsaKeys() + executer.PrepareTestFiles() + executer.PrepareGcc() + executer.MakeCheck() + ret = executer.ValidateFailures() + except Exception as e: + # At least log the exception on console. + print e + # The #4 element encodes the runtime exception. + ret = (1, '', '', 'Exception happened during execution: \n' + str(e)) + finally: + available_machine.Unlock(exclusive=True) + executer.CleanupIntermediateFiles() + executer.Cleanup() + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv)[0] + sys.exit(retval) diff --git a/deprecated/dejagnu/site.exp b/deprecated/dejagnu/site.exp new file mode 100644 index 00000000..beaa958d --- /dev/null +++ b/deprecated/dejagnu/site.exp @@ -0,0 +1 @@ +set target_list "chromeos-machine" diff --git a/deprecated/fdo_scripts/divide_and_merge_profiles.py b/deprecated/fdo_scripts/divide_and_merge_profiles.py new file mode 100755 index 00000000..5108aa6f --- /dev/null +++ b/deprecated/fdo_scripts/divide_and_merge_profiles.py @@ -0,0 +1,140 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +"""Script to divide and merge profiles.""" + +import copy +import optparse +import os +import pickle +import re +import sys +import tempfile + +import build_chrome_browser +import lock_machine +import run_tests +from cros_utils import command_executer +from cros_utils import logger + + +class ProfileMerger: + + def __init__(self, inputs, output, chunk_size, merge_program, multipliers): + self._inputs = inputs + self._output = output + self._chunk_size = chunk_size + self._merge_program = merge_program + self._multipliers = multipliers + self._ce = command_executer.GetCommandExecuter() + self._l = logger.GetLogger() + + def _GetFilesSetForInputDir(self, input_dir): + output_file = tempfile.mktemp() + command = "find %s -name '*.gcda' -o -name '*.imports' > %s" % (input_dir, + output_file) + self._ce.RunCommand(command) + files = open(output_file, 'r').read() + files_set = set([]) + for f in files.splitlines(): + stripped_file = f.replace(input_dir, '', 1) + stripped_file = stripped_file.lstrip('/') + files_set.add(stripped_file) + return files_set + + def _PopulateFilesSet(self): + self._files_set = set([]) + for i in self._inputs: + current_files_set = self._GetFilesSetForInputDir(i) + self._files_set.update(current_files_set) + + def _GetSubset(self): + ret = [] + for i in range(self._chunk_size): + if not self._files_set: + break + ret.append(self._files_set.pop()) + return ret + + def _CopyFilesTree(self, input_dir, files, output_dir): + for f in files: + src_file = os.path.join(input_dir, f) + dst_file = os.path.join(output_dir, f) + if not os.path.isdir(os.path.dirname(dst_file)): + command = 'mkdir -p %s' % os.path.dirname(dst_file) + self._ce.RunCommand(command) + command = 'cp %s %s' % (src_file, dst_file) + self._ce.RunCommand(command) + + def _DoChunkMerge(self, current_files): + temp_dirs = [] + for i in self._inputs: + temp_dir = tempfile.mkdtemp() + temp_dirs.append(temp_dir) + self._CopyFilesTree(i, current_files, temp_dir) + # Now do the merge. + command = ('%s --inputs=%s --output=%s' % + (self._merge_program, ','.join(temp_dirs), self._output)) + if self._multipliers: + command = ('%s --multipliers=%s' % (command, self._multipliers)) + ret = self._ce.RunCommand(command) + assert ret == 0, '%s command failed!' % command + for temp_dir in temp_dirs: + command = 'rm -rf %s' % temp_dir + self._ce.RunCommand(command) + + def DoMerge(self): + self._PopulateFilesSet() + while True: + current_files = self._GetSubset() + if not current_files: + break + self._DoChunkMerge(current_files) + + +def Main(argv): + """The main function.""" + # Common initializations + ### command_executer.InitCommandExecuter(True) + command_executer.InitCommandExecuter() + l = logger.GetLogger() + ce = command_executer.GetCommandExecuter() + parser = optparse.OptionParser() + parser.add_option('--inputs', + dest='inputs', + help='Comma-separated input profile directories to merge.') + parser.add_option('--output', dest='output', help='Output profile directory.') + parser.add_option('--chunk_size', + dest='chunk_size', + default='50', + help='Chunk size to divide up the profiles into.') + parser.add_option('--merge_program', + dest='merge_program', + default='/home/xur/bin/profile_merge_v15.par', + help='Merge program to use to do the actual merge.') + parser.add_option('--multipliers', + dest='multipliers', + help='multipliers to use when merging. (optional)') + + options, _ = parser.parse_args(argv) + + if not all([options.inputs, options.output]): + l.LogError('Must supply --inputs and --output') + return 1 + + try: + pm = ProfileMerger( + options.inputs.split(','), options.output, int(options.chunk_size), + options.merge_program, options.multipliers) + pm.DoMerge() + retval = 0 + except: + retval = 1 + finally: + print 'My work is done...' + return retval + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) diff --git a/deprecated/fdo_scripts/divide_and_merge_profiles_test.py b/deprecated/fdo_scripts/divide_and_merge_profiles_test.py new file mode 100755 index 00000000..2bfb5cf1 --- /dev/null +++ b/deprecated/fdo_scripts/divide_and_merge_profiles_test.py @@ -0,0 +1,127 @@ +#!/usr/bin/python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import os +import random +import shutil +import tempfile +import unittest + +from cros_utils import command_executer +from cros_utils import misc + + +class DivideAndMergeProfilesTest(unittest.TestCase): + + def tearDown(self): + shutil.rmtree(self._program_dir) + for profile_dir in self._profile_dirs: + shutil.rmtree(profile_dir) + + def setUp(self): + self._ce = command_executer.GetCommandExecuter() + self._program_dir = tempfile.mkdtemp() + self._writeProgram() + self._writeMakefile() + with misc.WorkingDirectory(self._program_dir): + self._ce.RunCommand('make') + num_profile_dirs = 2 + self._profile_dirs = [] + for i in range(num_profile_dirs): + profile_dir = tempfile.mkdtemp() + command = ('GCOV_PREFIX_STRIP=%s GCOV_PREFIX=$(/bin/pwd) ' + ' %s/program' % (profile_dir.count('/'), self._program_dir)) + with misc.WorkingDirectory(profile_dir): + self._ce.RunCommand(command) + self._profile_dirs.append(profile_dir) + self._merge_program = '/home/build/static/projects/crosstool/profile-merge/v14.5/profile_merge.par' + + def _writeMakefile(self): + makefile_contents = """ +CC = gcc + +CFLAGS = -fprofile-generate + +SRCS=$(wildcard *.c) + +OBJS=$(SRCS:.c=.o) + +all: program + +program: $(OBJS) + $(CC) -o $@ $^ $(CFLAGS) + +%.o: %.c + $(CC) -c -o $@ $^ $(CFLAGS)""" + + makefile = os.path.join(self._program_dir, 'Makefile') + with open(makefile, 'w') as f: + print >> f, makefile_contents + + def _writeProgram(self, num_files=100): + for i in range(num_files): + current_file = os.path.join(self._program_dir, '%s.c' % i) + with open(current_file, 'w') as f: + if i != num_files - 1: + print >> f, 'extern void foo%s();' % (i + 1) + print >> f, 'void foo%s(){foo%s();}' % (i, i + 1) + else: + print >> f, "void foo%s(){printf(\"\");}" % i + if i == 0: + print >> f, 'int main(){foo%s(); return 0;}' % i + + def testMerge(self): + reference_output = self._getReferenceOutput() + my_output = self._getMyOutput() + + ret = self._diffOutputs(reference_output, my_output) + shutil.rmtree(my_output) + shutil.rmtree(reference_output) + self.assertTrue(ret == 0) + + def _diffOutputs(self, reference, mine): + command = 'diff -uNr %s %s' % (reference, mine) + return self._ce.RunCommand(command) + + def _getMyOutput(self, args=''): + my_output = tempfile.mkdtemp() + my_merge_program = os.path.join( + os.path.dirname(__file__), 'divide_and_merge_profiles.py') + command = ('python %s --inputs=%s --output=%s ' + '--chunk_size=10 ' + '--merge_program=%s ' + '%s' % (my_merge_program, ','.join(self._profile_dirs), + my_output, self._merge_program, args)) + self._ce.RunCommand(command) + return my_output + + def _getReferenceOutput(self, args=''): + # First do a regular merge. + reference_output = tempfile.mkdtemp() + command = ('%s --inputs=%s --output=%s %s' % + (self._merge_program, ','.join(self._profile_dirs), + reference_output, args)) + self._ce.RunCommand(command) + return reference_output + + def testMergeWithMultipliers(self): + num_profiles = len(self._profile_dirs) + multipliers = [str(random.randint(0, num_profiles)) \ + for _ in range(num_profiles)] + args = '--multipliers=%s' % ','.join(multipliers) + + reference_output = self._getReferenceOutput(args) + my_output = self._getMyOutput(args) + + ret = self._diffOutputs(reference_output, my_output) + + shutil.rmtree(my_output) + shutil.rmtree(reference_output) + self.assertTrue(ret == 0) + + +if __name__ == '__main__': + unittest.main() diff --git a/deprecated/fdo_scripts/profile_cycler.py b/deprecated/fdo_scripts/profile_cycler.py new file mode 100755 index 00000000..176f2d4a --- /dev/null +++ b/deprecated/fdo_scripts/profile_cycler.py @@ -0,0 +1,199 @@ +#!/usr/bin/python2 +# +# Copyright 2011 Google Inc. All Rights Reserved. +"""Script to profile a page cycler, and get it back to the host.""" + +import copy +import optparse +import os +import pickle +import re +import sys +import tempfile +import time + +import build_chrome_browser +import cros_login +import lock_machine +import run_tests +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import misc + + +class CyclerProfiler: + REMOTE_TMP_DIR = '/tmp' + + def __init__(self, chromeos_root, board, cycler, profile_dir, remote): + self._chromeos_root = chromeos_root + self._cycler = cycler + self._profile_dir = profile_dir + self._remote = remote + self._board = board + self._ce = command_executer.GetCommandExecuter() + self._l = logger.GetLogger() + + self._gcov_prefix = os.path.join(self.REMOTE_TMP_DIR, self._GetProfileDir()) + + def _GetProfileDir(self): + return misc.GetCtargetFromBoard(self._board, self._chromeos_root) + + def _CopyTestData(self): + page_cycler_dir = os.path.join(self._chromeos_root, 'distfiles', 'target', + 'chrome-src-internal', 'src', 'data', + 'page_cycler') + if not os.path.isdir(page_cycler_dir): + raise RuntimeError('Page cycler dir %s not found!' % page_cycler_dir) + self._ce.CopyFiles(page_cycler_dir, + os.path.join(self.REMOTE_TMP_DIR, 'page_cycler'), + dest_machine=self._remote, + chromeos_root=self._chromeos_root, + recursive=True, + dest_cros=True) + + def _PrepareTestData(self): + # chmod files so everyone can read them. + command = ('cd %s && find page_cycler -type f | xargs chmod a+r' % + self.REMOTE_TMP_DIR) + self._ce.CrosRunCommand(command, + chromeos_root=self._chromeos_root, + machine=self._remote) + command = ('cd %s && find page_cycler -type d | xargs chmod a+rx' % + self.REMOTE_TMP_DIR) + self._ce.CrosRunCommand(command, + chromeos_root=self._chromeos_root, + machine=self._remote) + + def _CopyProfileToHost(self): + dest_dir = os.path.join(self._profile_dir, + os.path.basename(self._gcov_prefix)) + # First remove the dir if it exists already + if os.path.exists(dest_dir): + command = 'rm -rf %s' % dest_dir + self._ce.RunCommand(command) + + # Strip out the initial prefix for the Chrome directory before doing the + # copy. + chrome_dir_prefix = misc.GetChromeSrcDir() + + command = 'mkdir -p %s' % dest_dir + self._ce.RunCommand(command) + self._ce.CopyFiles(self._gcov_prefix, + dest_dir, + src_machine=self._remote, + chromeos_root=self._chromeos_root, + recursive=True, + src_cros=True) + + def _RemoveRemoteProfileDir(self): + command = 'rm -rf %s' % self._gcov_prefix + self._ce.CrosRunCommand(command, + chromeos_root=self._chromeos_root, + machine=self._remote) + + def _LaunchCycler(self, cycler): + command = ( + 'DISPLAY=:0 ' + 'XAUTHORITY=/home/chronos/.Xauthority ' + 'GCOV_PREFIX=%s ' + 'GCOV_PREFIX_STRIP=3 ' + '/opt/google/chrome/chrome ' + '--no-sandbox ' + '--renderer-clean-exit ' + '--user-data-dir=$(mktemp -d) ' + "--url \"file:///%s/page_cycler/%s/start.html?iterations=10&auto=1\" " + '--enable-file-cookies ' + '--no-first-run ' + '--js-flags=expose_gc &' % (self._gcov_prefix, self.REMOTE_TMP_DIR, + cycler)) + + self._ce.CrosRunCommand(command, + chromeos_root=self._chromeos_root, + machine=self._remote, + command_timeout=60) + + def _PkillChrome(self, signal='9'): + command = 'pkill -%s chrome' % signal + self._ce.CrosRunCommand(command, + chromeos_root=self._chromeos_root, + machine=self._remote) + + def DoProfile(self): + # Copy the page cycler data to the remote + self._CopyTestData() + self._PrepareTestData() + self._RemoveRemoteProfileDir() + + for cycler in self._cycler.split(','): + self._ProfileOneCycler(cycler) + + # Copy the profile back + self._CopyProfileToHost() + + def _ProfileOneCycler(self, cycler): + # With aura, all that's needed is a stop/start ui. + self._PkillChrome() + cros_login.RestartUI(self._remote, self._chromeos_root, login=False) + # Run the cycler + self._LaunchCycler(cycler) + self._PkillChrome(signal='INT') + # Let libgcov dump the profile. + # TODO(asharif): There is a race condition here. Fix it later. + time.sleep(30) + + +def Main(argv): + """The main function.""" + # Common initializations + ### command_executer.InitCommandExecuter(True) + command_executer.InitCommandExecuter() + l = logger.GetLogger() + ce = command_executer.GetCommandExecuter() + parser = optparse.OptionParser() + parser.add_option('--cycler', + dest='cycler', + default='alexa_us', + help=('Comma-separated cyclers to profile. ' + 'Example: alexa_us,moz,moz2' + 'Use all to profile all cyclers.')) + parser.add_option('--chromeos_root', + dest='chromeos_root', + default='../../', + help='Output profile directory.') + parser.add_option('--board', + dest='board', + default='x86-zgb', + help='The target board.') + parser.add_option('--remote', + dest='remote', + help=('The remote chromeos machine that' + ' has the profile image.')) + parser.add_option('--profile_dir', + dest='profile_dir', + default='profile_dir', + help='Store profiles in this directory.') + + options, _ = parser.parse_args(argv) + + all_cyclers = ['alexa_us', 'bloat', 'dhtml', 'dom', 'intl1', 'intl2', + 'morejs', 'morejsnp', 'moz', 'moz2'] + + if options.cycler == 'all': + options.cycler = ','.join(all_cyclers) + + try: + cp = CyclerProfiler(options.chromeos_root, options.board, options.cycler, + options.profile_dir, options.remote) + cp.DoProfile() + retval = 0 + except Exception as e: + retval = 1 + print e + finally: + print 'Exiting...' + return retval + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) diff --git a/deprecated/fdo_scripts/summarize_hot_blocks.py b/deprecated/fdo_scripts/summarize_hot_blocks.py new file mode 100644 index 00000000..20c07fa4 --- /dev/null +++ b/deprecated/fdo_scripts/summarize_hot_blocks.py @@ -0,0 +1,187 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +"""Summarize hottest basic blocks found while doing a ChromeOS FDO build. + +Here is an example execution: + + summarize_hot_blocks.py + --data_dir=~/chromeos/chroot/var/cache/chromeos-chrome/ --cutoff=10000 + --output_dir=/home/x/y + +With the cutoff, it will ignore any basic blocks that have a count less +than what is specified (in this example 10000) +The script looks inside the directory (this is typically a directory where +the object files are generated) for files with *.profile and *.optimized +suffixes. To get these, the following flags were added to the compiler +invokation within vanilla_vs_fdo.py in the profile-use phase. + + "-fdump-tree-optimized-blocks-lineno " + "-fdump-ipa-profile-blocks-lineno " + +Here is an example of the *.profile and *.optimized files contents: + +# BLOCK 7 freq:3901 count:60342, starting at line 92 +# PRED: 6 [39.0%] count:60342 (true,exec) + [url_canon_internal.cc : 92:28] MEM[(const char * *)source_6(D) + 16B] = + D.28080_17; + [url_canon_internal.cc : 93:41] MEM[(struct Component *)parsed_4(D) + 16B] = + MEM[(const struct Component &)repl_1(D) + 80]; +# SUCC: 8 [100.0%] count:60342 (fallthru,exec) +# BLOCK 8 freq:10000 count:154667, starting at line 321 +# PRED: 7 [100.0%] count:60342 (fallthru,exec) 6 [61.0%] count:94325 +(false,exec) + [url_canon_internal.cc : 321:51] # DEBUG D#10 => + [googleurl/src/url_canon_internal.cc : 321] &parsed_4(D)->host + +this script finds the blocks with highest count and shows the first line +of each block so that it is easy to identify the origin of the basic block. + +""" + +__author__ = 'llozano@google.com (Luis Lozano)' + +import optparse +import os +import re +import shutil +import sys +import tempfile + +from cros_utils import command_executer + + +# Given a line, check if it has a block count and return it. +# Return -1 if there is no match +def GetBlockCount(line): + match_obj = re.match('.*# BLOCK \d+ .*count:(\d+)', line) + if match_obj: + return int(match_obj.group(1)) + else: + return -1 + + +class Collector(object): + + def __init__(self, data_dir, cutoff, output_dir, tempdir): + self._data_dir = data_dir + self._cutoff = cutoff + self._output_dir = output_dir + self._tempdir = tempdir + self._ce = command_executer.GetCommandExecuter() + + def CollectFileList(self, file_exp, list_file): + command = ("find %s -type f -name '%s' > %s" % + (self._data_dir, file_exp, + os.path.join(self._tempdir, list_file))) + ret = self._ce.RunCommand(command) + if ret: + raise RuntimeError('Failed: %s' % command) + + def SummarizeLines(self, data_file): + sum_lines = [] + search_lno = False + for line in data_file: + count = GetBlockCount(line) + if count != -1: + if count >= self._cutoff: + search_lno = True + sum_line = line.strip() + sum_count = count + # look for a line that starts with line number information + elif search_lno and re.match('^\s*\[.*: \d*:\d*]', line): + search_lno = False + sum_lines.append('%d:%s: %s %s' % + (sum_count, data_file.name, sum_line, line)) + return sum_lines + + # Look for blocks in the data file that have a count larger than the cutoff + # and generate a sorted summary file of the hottest blocks. + def SummarizeFile(self, data_file, sum_file): + with open(data_file, 'r') as f: + sum_lines = self.SummarizeLines(f) + + # sort reverse the list in place by the block count number + sum_lines.sort(key=GetBlockCount, reverse=True) + + with open(sum_file, 'w') as sf: + sf.write(''.join(sum_lines)) + + print 'Generated file Summary: ', sum_file + + # Find hottest blocks in the list of files, generate a sorted summary for + # each file and then do a sorted merge of all the summaries. + def SummarizeList(self, list_file, summary_file): + with open(os.path.join(self._tempdir, list_file)) as f: + sort_list = [] + for file_name in f: + file_name = file_name.strip() + sum_file = '%s.sum' % file_name + sort_list.append('%s%s' % (sum_file, chr(0))) + self.SummarizeFile(file_name, sum_file) + + tmp_list_file = os.path.join(self._tempdir, 'file_list.dat') + with open(tmp_list_file, 'w') as file_list_file: + for x in sort_list: + file_list_file.write(x) + + merge_command = ('sort -nr -t: -k1 --merge --files0-from=%s > %s ' % + (tmp_list_file, summary_file)) + + ret = self._ce.RunCommand(merge_command) + if ret: + raise RuntimeError('Failed: %s' % merge_command) + print 'Generated general summary: ', summary_file + + def SummarizePreOptimized(self, summary_file): + self.CollectFileList('*.profile', 'chrome.profile.list') + self.SummarizeList('chrome.profile.list', + os.path.join(self._output_dir, summary_file)) + + def SummarizeOptimized(self, summary_file): + self.CollectFileList('*.optimized', 'chrome.optimized.list') + self.SummarizeList('chrome.optimized.list', + os.path.join(self._output_dir, summary_file)) + + +def Main(argv): + command_executer.InitCommandExecuter() + usage = ('usage: %prog --data_dir=<dir> --cutoff=<value> ' + '--output_dir=<dir> [--keep_tmp]') + parser = optparse.OptionParser(usage=usage) + parser.add_option('--data_dir', + dest='data_dir', + help=('directory where the FDO (*.profile and ' + '*.optimized) files are located')) + parser.add_option('--cutoff', + dest='cutoff', + help='Minimum count to consider for each basic block') + parser.add_option('--output_dir', + dest='output_dir', + help=('directory where summary data will be generated' + '(pre_optimized.txt, optimized.txt)')) + parser.add_option('--keep_tmp', + action='store_true', + dest='keep_tmp', + default=False, + help=('Keep directory with temporary files' + '(for debugging purposes)')) + options = parser.parse_args(argv)[0] + if not all((options.data_dir, options.cutoff, options.output_dir)): + parser.print_help() + sys.exit(1) + + tempdir = tempfile.mkdtemp() + + co = Collector(options.data_dir, int(options.cutoff), options.output_dir, + tempdir) + co.SummarizePreOptimized('pre_optimized.txt') + co.SummarizeOptimized('optimized.txt') + + if not options.keep_tmp: + shutil.rmtree(tempdir, ignore_errors=True) + + return 0 + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) diff --git a/deprecated/fdo_scripts/vanilla_vs_fdo.py b/deprecated/fdo_scripts/vanilla_vs_fdo.py new file mode 100644 index 00000000..6f42839d --- /dev/null +++ b/deprecated/fdo_scripts/vanilla_vs_fdo.py @@ -0,0 +1,312 @@ +# Copyright 2011 Google Inc. All Rights Reserved. +"""Script to build chrome with FDO and compare performance against no FDO.""" + +import getpass +import optparse +import os +import sys + +import image_chromeos +import setup_chromeos +from cros_utils import command_executer +from cros_utils import misc +from cros_utils import logger + + +class Patcher(object): + + def __init__(self, dir_to_patch, patch_file): + self._dir_to_patch = dir_to_patch + self._patch_file = patch_file + self._base_patch_command = 'patch -p0 %%s < %s' % patch_file + self._ce = command_executer.GetCommandExecuter() + + def _RunPatchCommand(self, args): + patch_command = self._base_patch_command % args + command = ('cd %s && %s' % (self._dir_to_patch, patch_command)) + return self._ce.RunCommand(command) + + def _ApplyPatch(self, args): + full_args = '%s --dry-run' % args + ret = self._RunPatchCommand(full_args) + if ret: + raise RuntimeError('Patch dry run failed!') + ret = self._RunPatchCommand(args) + if ret: + raise RuntimeError('Patch application failed!') + + def __enter__(self): + self._ApplyPatch('') + + def __exit__(self, type, value, traceback): + self._ApplyPatch('-R') + + +class FDOComparator(object): + + def __init__(self, board, remotes, ebuild_version, plus_pgo, minus_pgo, + update_pgo, chromeos_root): + self._board = board + self._remotes = remotes + self._ebuild_version = ebuild_version + self._remote = remotes.split(',')[0] + self._chromeos_root = chromeos_root + self._profile_dir = 'profile_dir' + self._profile_path = os.path.join(self._chromeos_root, 'src', 'scripts', + os.path.basename(self._profile_dir)) + self._plus_pgo = plus_pgo + self._minus_pgo = minus_pgo + self._update_pgo = update_pgo + + self._ce = command_executer.GetCommandExecuter() + self._l = logger.GetLogger() + + def _CheckoutChromeOS(self): + if not os.path.exists(self._chromeos_root): + setup_chromeos_args = [setup_chromeos.__file__, + '--dir=%s' % self._chromeos_root, '--minilayout'] + setup_chromeos.Main(setup_chromeos_args) + + def _BuildChromeOSUsingBinaries(self): + image_dir = misc.GetImageDir(self._chromeos_root, self._board) + command = 'equery-%s l chromeos' % self._board + ret = self._ce.ChrootRunCommand(self._chromeos_root, command) + if ret: + command = misc.GetSetupBoardCommand(self._board, usepkg=True) + ret = self._ce.ChrootRunCommand(self._chromeos_root, command) + if ret: + raise RuntimeError("Couldn't run setup_board!") + command = misc.GetBuildPackagesCommand(self._board, True) + ret = self._ce.ChrootRunCommand(self._chromeos_root, command) + if ret: + raise RuntimeError("Couldn't run build_packages!") + + def _ReportMismatches(self, build_log): + mismatch_signature = '-Wcoverage-mismatch' + mismatches = build_log.count(mismatch_signature) + self._l.LogOutput('Total mismatches: %s' % mismatches) + stale_files = set([]) + for line in build_log.splitlines(): + if mismatch_signature in line: + filename = line.split(':')[0] + stale_files.add(filename) + self._l.LogOutput('Total stale files: %s' % len(stale_files)) + + def _BuildChromeAndImage(self, + ebuild_version='', + env_dict={}, + cflags='', + cxxflags='', + ldflags='', + label='', + build_image_args=''): + env_string = misc.GetEnvStringFromDict(env_dict) + if not label: + label = ' '.join([env_string, cflags, cxxflags, ldflags, ebuild_version]) + label = label.strip() + label = misc.GetFilenameFromString(label) + if not misc.DoesLabelExist(self._chromeos_root, self._board, label): + build_chrome_browser_args = ['--clean', '--chromeos_root=%s' % + self._chromeos_root, '--board=%s' % + self._board, '--env=%r' % env_string, + '--cflags=%r' % cflags, '--cxxflags=%r' % + cxxflags, '--ldflags=%r' % ldflags, + '--ebuild_version=%s' % ebuild_version, + '--build_image_args=%s' % build_image_args] + + build_chrome_browser = os.path.join( + os.path.dirname(__file__), '..', 'build_chrome_browser.py') + command = 'python %s %s' % (build_chrome_browser, + ' '.join(build_chrome_browser_args)) + ret, out, err = self._ce.RunCommandWOutput(command) + if '-fprofile-use' in cxxflags: + self._ReportMismatches(out) + + if ret: + raise RuntimeError("Couldn't build chrome browser!") + misc.LabelLatestImage(self._chromeos_root, self._board, label) + return label + + def _TestLabels(self, labels): + experiment_file = 'pgo_experiment.txt' + experiment_header = """ + board: %s + remote: %s + """ % (self._board, self._remotes) + experiment_tests = """ + benchmark: desktopui_PyAutoPerfTests { + iterations: 1 + } + """ + + with open(experiment_file, 'w') as f: + print >> f, experiment_header + print >> f, experiment_tests + for label in labels: + # TODO(asharif): Fix crosperf so it accepts labels with symbols + crosperf_label = label + crosperf_label = crosperf_label.replace('-', 'minus') + crosperf_label = crosperf_label.replace('+', 'plus') + experiment_image = """ + %s { + chromeos_image: %s + } + """ % (crosperf_label, os.path.join( + misc.GetImageDir(self._chromeos_root, self._board), label, + 'chromiumos_test_image.bin')) + print >> f, experiment_image + crosperf = os.path.join( + os.path.dirname(__file__), '..', 'crosperf', 'crosperf') + command = '%s %s' % (crosperf, experiment_file) + ret = self._ce.RunCommand(command) + if ret: + raise RuntimeError("Couldn't run crosperf!") + + def _ImageRemote(self, label): + image_path = os.path.join( + misc.GetImageDir(self._chromeos_root, + self._board), label, 'chromiumos_test_image.bin') + image_chromeos_args = [image_chromeos.__file__, '--chromeos_root=%s' % + self._chromeos_root, '--image=%s' % image_path, + '--remote=%s' % self._remote, + '--board=%s' % self._board] + image_chromeos.Main(image_chromeos_args) + + def _ProfileRemote(self): + profile_cycler = os.path.join( + os.path.dirname(__file__), 'profile_cycler.py') + profile_cycler_args = ['--chromeos_root=%s' % self._chromeos_root, + '--cycler=all', '--board=%s' % self._board, + '--profile_dir=%s' % self._profile_path, + '--remote=%s' % self._remote] + command = 'python %s %s' % (profile_cycler, ' '.join(profile_cycler_args)) + ret = self._ce.RunCommand(command) + if ret: + raise RuntimeError("Couldn't profile cycler!") + + def _BuildGenerateImage(self): + # TODO(asharif): add cflags as well. + labels_list = ['fprofile-generate', self._ebuild_version] + label = '_'.join(labels_list) + generate_label = self._BuildChromeAndImage( + env_dict={'USE': 'chrome_internal -pgo pgo_generate'}, + label=label, + ebuild_version=self._ebuild_version, + build_image_args='--rootfs_boost_size=400') + return generate_label + + def _BuildUseImage(self): + ctarget = misc.GetCtargetFromBoard(self._board, self._chromeos_root) + chroot_profile_dir = os.path.join('/home/%s/trunk' % getpass.getuser(), + 'src', 'scripts', self._profile_dir, + ctarget) + cflags = ('-fprofile-use ' + '-fprofile-correction ' + '-Wno-error ' + '-fdump-tree-optimized-blocks-lineno ' + '-fdump-ipa-profile-blocks-lineno ' + '-fno-vpt ' + '-fprofile-dir=%s' % chroot_profile_dir) + labels_list = ['updated_pgo', self._ebuild_version] + label = '_'.join(labels_list) + pgo_use_label = self._BuildChromeAndImage( + env_dict={'USE': 'chrome_internal -pgo'}, + cflags=cflags, + cxxflags=cflags, + ldflags=cflags, + label=label, + ebuild_version=self._ebuild_version) + return pgo_use_label + + def DoAll(self): + self._CheckoutChromeOS() + self._BuildChromeOSUsingBinaries() + labels = [] + + if self._minus_pgo: + minus_pgo = self._BuildChromeAndImage( + env_dict={'USE': 'chrome_internal -pgo'}, + ebuild_version=self._ebuild_version) + labels.append(minus_pgo) + if self._plus_pgo: + plus_pgo = self._BuildChromeAndImage( + env_dict={'USE': 'chrome_internal pgo'}, + ebuild_version=self._ebuild_version) + labels.append(plus_pgo) + + if self._update_pgo: + if not os.path.exists(self._profile_path): + # Build Chrome with -fprofile-generate + generate_label = self._BuildGenerateImage() + # Image to the remote box. + self._ImageRemote(generate_label) + # Profile it using all page cyclers. + self._ProfileRemote() + + # Use the profile directory to rebuild it. + updated_pgo_label = self._BuildUseImage() + labels.append(updated_pgo_label) + + # Run crosperf on all images now. + self._TestLabels(labels) + return 0 + + +def Main(argv): + """The main function.""" + # Common initializations + ### command_executer.InitCommandExecuter(True) + command_executer.InitCommandExecuter() + parser = optparse.OptionParser() + parser.add_option('--remote', + dest='remote', + help='Remote machines to run tests on.') + parser.add_option('--board', + dest='board', + default='x86-zgb', + help='The target board.') + parser.add_option('--ebuild_version', + dest='ebuild_version', + default='', + help='The Chrome ebuild version to use.') + parser.add_option('--plus_pgo', + dest='plus_pgo', + action='store_true', + default=False, + help='Build USE=+pgo.') + parser.add_option('--minus_pgo', + dest='minus_pgo', + action='store_true', + default=False, + help='Build USE=-pgo.') + parser.add_option('--update_pgo', + dest='update_pgo', + action='store_true', + default=False, + help='Update pgo and build Chrome with the update.') + parser.add_option('--chromeos_root', + dest='chromeos_root', + default=False, + help='The chromeos root directory') + options, _ = parser.parse_args(argv) + if not options.board: + print 'Please give a board.' + return 1 + if not options.remote: + print 'Please give at least one remote machine.' + return 1 + if not options.chromeos_root: + print 'Please provide the chromeos root directory.' + return 1 + if not any((options.minus_pgo, options.plus_pgo, options.update_pgo)): + print 'Please provide at least one build option.' + return 1 + fc = FDOComparator(options.board, options.remote, options.ebuild_version, + options.plus_pgo, options.minus_pgo, options.update_pgo, + os.path.expanduser(options.chromeos_root)) + return fc.DoAll() + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) diff --git a/deprecated/generate-waterfall-reports.py b/deprecated/generate-waterfall-reports.py new file mode 100755 index 00000000..a67cd6ca --- /dev/null +++ b/deprecated/generate-waterfall-reports.py @@ -0,0 +1,853 @@ +#!/usr/bin/env python2 +"""Generate summary report for ChromeOS toolchain waterfalls.""" + +# Desired future features (to be added): +# - arguments to allow generating only the main waterfall report, +# or only the rotating builder reports, or only the failures +# report; or the waterfall reports without the failures report. +# - Better way of figuring out which dates/builds to generate +# reports for: probably an argument specifying a date or a date +# range, then use something like the new buildbot utils to +# query the build logs to find the right build numbers for the +# builders for the specified dates. +# - Store/get the json/data files in mobiletc-prebuild's x20 area. +# - Update data in json file to reflect, for each testsuite, which +# tests are not expected to run on which boards; update this +# script to use that data appropriately. +# - Make sure user's prodaccess is up-to-date before trying to use +# this script. +# - Add some nice formatting/highlighting to reports. + +from __future__ import print_function + +import argparse +import getpass +import json +import os +import re +import shutil +import sys +import time + +from cros_utils import command_executer + +# All the test suites whose data we might want for the reports. +TESTS = (('bvt-inline', 'HWTest'), ('bvt-cq', 'HWTest'), ('security', 'HWTest'), + ('kernel_daily_regression', 'HWTest'), ('kernel_daily_benchmarks', + 'HWTest'),) + +# The main waterfall builders, IN THE ORDER IN WHICH WE WANT THEM +# LISTED IN THE REPORT. +WATERFALL_BUILDERS = [ + 'amd64-llvm-next-toolchain', + 'arm-llvm-next-toolchain', + 'arm64-llvm-next-toolchain', +] + +DATA_DIR = '/google/data/rw/users/mo/mobiletc-prebuild/waterfall-report-data/' +ARCHIVE_DIR = '/google/data/rw/users/mo/mobiletc-prebuild/waterfall-reports/' +DOWNLOAD_DIR = '/tmp/waterfall-logs' +MAX_SAVE_RECORDS = 7 +BUILD_DATA_FILE = '%s/build-data.txt' % DATA_DIR +GCC_ROTATING_BUILDER = 'gcc_toolchain' +LLVM_ROTATING_BUILDER = 'llvm_next_toolchain' +ROTATING_BUILDERS = [GCC_ROTATING_BUILDER, LLVM_ROTATING_BUILDER] + +# For int-to-string date conversion. Note, the index of the month in this +# list needs to correspond to the month's integer value. i.e. 'Sep' must +# be as MONTHS[9]. +MONTHS = [ + '', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', + 'Nov', 'Dec' +] + + +def format_date(int_date): + """Convert an integer date to a string date. YYYYMMDD -> YYYY-MMM-DD""" + + if int_date == 0: + return 'today' + + tmp_date = int_date + day = tmp_date % 100 + tmp_date = tmp_date / 100 + month = tmp_date % 100 + year = tmp_date / 100 + + month_str = MONTHS[month] + date_str = '%d-%s-%d' % (year, month_str, day) + return date_str + + +def EmailReport(report_file, report_type, date, email_to): + subject = '%s Waterfall Summary report, %s' % (report_type, date) + sendgmr_path = '/google/data/ro/projects/gws-sre/sendgmr' + command = ('%s --to=%s --subject="%s" --body_file=%s' % + (sendgmr_path, email_to, subject, report_file)) + command_executer.GetCommandExecuter().RunCommand(command) + + +def PruneOldFailures(failure_dict, int_date): + earliest_date = int_date - MAX_SAVE_RECORDS + for suite in failure_dict: + suite_dict = failure_dict[suite] + test_keys_to_remove = [] + for test in suite_dict: + test_dict = suite_dict[test] + msg_keys_to_remove = [] + for msg in test_dict: + fails = test_dict[msg] + i = 0 + while i < len(fails) and fails[i][0] <= earliest_date: + i += 1 + new_fails = fails[i:] + test_dict[msg] = new_fails + if len(new_fails) == 0: + msg_keys_to_remove.append(msg) + + for k in msg_keys_to_remove: + del test_dict[k] + + suite_dict[test] = test_dict + if len(test_dict) == 0: + test_keys_to_remove.append(test) + + for k in test_keys_to_remove: + del suite_dict[k] + + failure_dict[suite] = suite_dict + + +def GetBuildID(build_bot, date): + """Get the build id for a build_bot at a given date.""" + day = '{day:02d}'.format(day=date % 100) + mon = MONTHS[date / 100 % 100] + date_string = mon + ' ' + day + if build_bot in WATERFALL_BUILDERS: + url = 'https://uberchromegw.corp.google.com/i/chromeos/' + \ + 'builders/%s?numbuilds=200' % build_bot + if build_bot in ROTATING_BUILDERS: + url = 'https://uberchromegw.corp.google.com/i/chromiumos.tryserver/' + \ + 'builders/%s?numbuilds=200' % build_bot + command = 'sso_client %s' % url + retval = 1 + retry_time = 3 + while retval and retry_time: + retval, output, _ = \ + command_executer.GetCommandExecuter().RunCommandWOutput(command, \ + print_to_console=False) + retry_time -= 1 + + if retval: + return [] + + out = output.split('\n') + line_num = 0 + build_id = [] + # Parse the output like this + # <td>Dec 14 10:55</td> + # <td class="revision">??</td> + # <td failure</td><td><a href="../builders/gcc_toolchain/builds/109">#109</a> + while line_num < len(out): + if date_string in out[line_num]: + if line_num + 2 < len(out): + build_num_line = out[line_num + 2] + raw_num = re.findall(r'builds/\d+', build_num_line) + # raw_num is ['builds/109'] in the example. + if raw_num: + build_id.append(int(raw_num[0].split('/')[1])) + line_num += 1 + return build_id + + +def GenerateFailuresReport(fail_dict, date): + filename = 'waterfall_report.failures.%s.txt' % date + date_string = format_date(date) + with open(filename, 'w') as out_file: + # Write failure report section. + out_file.write('\n\nSummary of Test Failures as of %s\n\n' % date_string) + + # We want to sort the errors and output them in order of the ones that occur + # most often. So we have to collect the data about all of them, then sort + # it. + error_groups = [] + for suite in fail_dict: + suite_dict = fail_dict[suite] + if suite_dict: + for test in suite_dict: + test_dict = suite_dict[test] + for err_msg in test_dict: + err_list = test_dict[err_msg] + sorted_list = sorted(err_list, key=lambda x: x[0], reverse=True) + err_group = [len(sorted_list), suite, test, err_msg, sorted_list] + error_groups.append(err_group) + + # Sort the errors by the number of errors of each type. Then output them in + # order. + sorted_errors = sorted(error_groups, key=lambda x: x[0], reverse=True) + for i in range(0, len(sorted_errors)): + err_group = sorted_errors[i] + suite = err_group[1] + test = err_group[2] + err_msg = err_group[3] + err_list = err_group[4] + out_file.write('Suite: %s\n' % suite) + out_file.write(' %s (%d failures)\n' % (test, len(err_list))) + out_file.write(' (%s)\n' % err_msg) + for i in range(0, len(err_list)): + err = err_list[i] + out_file.write(' %s, %s, %s\n' % (format_date(err[0]), err[1], + err[2])) + out_file.write('\n') + + print('Report generated in %s.' % filename) + return filename + + +def GenerateWaterfallReport(report_dict, fail_dict, waterfall_type, date, + omit_failures): + """Write out the actual formatted report.""" + + filename = 'waterfall_report.%s_waterfall.%s.txt' % (waterfall_type, date) + + date_string = '' + date_list = report_dict['date'] + num_dates = len(date_list) + i = 0 + for d in date_list: + date_string += d + if i < num_dates - 1: + date_string += ', ' + i += 1 + + if waterfall_type == 'main': + report_list = WATERFALL_BUILDERS + else: + report_list = report_dict.keys() + + with open(filename, 'w') as out_file: + # Write Report Header + out_file.write('\nStatus of %s Waterfall Builds from %s\n\n' % + (waterfall_type, date_string)) + out_file.write(' ' + ' kernel kernel\n') + out_file.write(' Build bvt- bvt-cq ' + ' security daily daily\n') + out_file.write(' status inline ' + ' regression benchmarks\n') + out_file.write(' [P/ F/ DR]* [P/ F /DR]* ' + '[P/ F/ DR]* [P/ F/ DR]* [P/ F/ DR]*\n\n') + + # Write daily waterfall status section. + for i in range(0, len(report_list)): + builder = report_list[i] + if builder == 'date': + continue + + if builder not in report_dict: + out_file.write('Unable to find information for %s.\n\n' % builder) + continue + + build_dict = report_dict[builder] + status = build_dict.get('build_status', 'bad') + inline = build_dict.get('bvt-inline', '[??/ ?? /??]') + cq = build_dict.get('bvt-cq', '[??/ ?? /??]') + inline_color = build_dict.get('bvt-inline-color', '') + cq_color = build_dict.get('bvt-cq-color', '') + if 'x86' not in builder: + security = build_dict.get('security', '[??/ ?? /??]') + security_color = build_dict.get('security-color', '') + if 'gcc' in builder: + regression = build_dict.get('kernel_daily_regression', '[??/ ?? /??]') + bench = build_dict.get('kernel_daily_benchmarks', '[??/ ?? /??]') + regression_color = build_dict.get('kernel_daily_regression-color', '') + bench_color = build_dict.get('kernel_daily_benchmarks-color', '') + out_file.write(' %6s %6s' + ' %6s %6s %6s\n' % + (inline_color, cq_color, security_color, + regression_color, bench_color)) + out_file.write('%25s %3s %s %s %s %s %s\n' % + (builder, status, inline, cq, security, regression, + bench)) + else: + out_file.write(' %6s %6s' + ' %6s\n' % (inline_color, cq_color, + security_color)) + out_file.write('%25s %3s %s %s %s\n' % (builder, status, inline, cq, + security)) + else: + out_file.write(' %6s %6s\n' % + (inline_color, cq_color)) + out_file.write('%25s %3s %s %s\n' % (builder, status, inline, cq)) + if 'build_link' in build_dict: + out_file.write('%s\n\n' % build_dict['build_link']) + + out_file.write('\n\n*P = Number of tests in suite that Passed; F = ' + 'Number of tests in suite that Failed; DR = Number of tests' + ' in suite that Didn\'t Run.\n') + + if omit_failures: + print('Report generated in %s.' % filename) + return filename + + # Write failure report section. + out_file.write('\n\nSummary of Test Failures as of %s\n\n' % date_string) + + # We want to sort the errors and output them in order of the ones that occur + # most often. So we have to collect the data about all of them, then sort + # it. + error_groups = [] + for suite in fail_dict: + suite_dict = fail_dict[suite] + if suite_dict: + for test in suite_dict: + test_dict = suite_dict[test] + for err_msg in test_dict: + err_list = test_dict[err_msg] + sorted_list = sorted(err_list, key=lambda x: x[0], reverse=True) + err_group = [len(sorted_list), suite, test, err_msg, sorted_list] + error_groups.append(err_group) + + # Sort the errors by the number of errors of each type. Then output them in + # order. + sorted_errors = sorted(error_groups, key=lambda x: x[0], reverse=True) + for i in range(0, len(sorted_errors)): + err_group = sorted_errors[i] + suite = err_group[1] + test = err_group[2] + err_msg = err_group[3] + err_list = err_group[4] + out_file.write('Suite: %s\n' % suite) + out_file.write(' %s (%d failures)\n' % (test, len(err_list))) + out_file.write(' (%s)\n' % err_msg) + for i in range(0, len(err_list)): + err = err_list[i] + out_file.write(' %s, %s, %s\n' % (format_date(err[0]), err[1], + err[2])) + out_file.write('\n') + + print('Report generated in %s.' % filename) + return filename + + +def UpdateReport(report_dict, builder, test, report_date, build_link, + test_summary, board, color): + """Update the data in our report dictionary with current test's data.""" + + if 'date' not in report_dict: + report_dict['date'] = [report_date] + elif report_date not in report_dict['date']: + # It is possible that some of the builders started/finished on different + # days, so we allow for multiple dates in the reports. + report_dict['date'].append(report_date) + + build_key = '' + if builder == GCC_ROTATING_BUILDER: + build_key = '%s-gcc-toolchain' % board + elif builder == LLVM_ROTATING_BUILDER: + build_key = '%s-llvm-next-toolchain' % board + else: + build_key = builder + + if build_key not in report_dict.keys(): + build_dict = dict() + else: + build_dict = report_dict[build_key] + + if 'build_link' not in build_dict: + build_dict['build_link'] = build_link + + if 'date' not in build_dict: + build_dict['date'] = report_date + + if 'board' in build_dict and build_dict['board'] != board: + raise RuntimeError( + 'Error: Two different boards (%s,%s) in one build (%s)!' % + (board, build_dict['board'], build_link)) + build_dict['board'] = board + + color_key = '%s-color' % test + build_dict[color_key] = color + + # Check to see if we already have a build status for this build_key + status = '' + if 'build_status' in build_dict.keys(): + # Use current build_status, unless current test failed (see below). + status = build_dict['build_status'] + + if not test_summary: + # Current test data was not available, so something was bad with build. + build_dict['build_status'] = 'bad' + build_dict[test] = '[ no data ]' + else: + build_dict[test] = test_summary + if not status: + # Current test ok; no other data, so assume build was ok. + build_dict['build_status'] = 'ok' + + report_dict[build_key] = build_dict + + +def UpdateBuilds(builds): + """Update the data in our build-data.txt file.""" + + # The build data file records the last build number for which we + # generated a report. When we generate the next report, we read + # this data and increment it to get the new data; when we finish + # generating the reports, we write the updated values into this file. + # NOTE: One side effect of doing this at the end: If the script + # fails in the middle of generating a report, this data does not get + # updated. + with open(BUILD_DATA_FILE, 'w') as fp: + gcc_max = 0 + llvm_max = 0 + for b in builds: + if b[0] == GCC_ROTATING_BUILDER: + gcc_max = max(gcc_max, b[1]) + elif b[0] == LLVM_ROTATING_BUILDER: + llvm_max = max(llvm_max, b[1]) + else: + fp.write('%s,%d\n' % (b[0], b[1])) + if gcc_max > 0: + fp.write('%s,%d\n' % (GCC_ROTATING_BUILDER, gcc_max)) + if llvm_max > 0: + fp.write('%s,%d\n' % (LLVM_ROTATING_BUILDER, llvm_max)) + + +def GetBuilds(date=0): + """Get build id from builds.""" + + # If date is set, get the build id from waterfall. + builds = [] + + if date: + for builder in WATERFALL_BUILDERS + ROTATING_BUILDERS: + build_ids = GetBuildID(builder, date) + for build_id in build_ids: + builds.append((builder, build_id)) + return builds + + # If date is not set, we try to get the most recent builds. + # Read the values of the last builds used to generate a report, and + # increment them appropriately, to get values for generating the + # current report. (See comments in UpdateBuilds). + with open(BUILD_DATA_FILE, 'r') as fp: + lines = fp.readlines() + + for l in lines: + l = l.rstrip() + words = l.split(',') + builder = words[0] + build = int(words[1]) + builds.append((builder, build + 1)) + # NOTE: We are assuming here that there are always 2 daily builds in + # each of the rotating builders. I am not convinced this is a valid + # assumption. + if builder in ROTATING_BUILDERS: + builds.append((builder, build + 2)) + + return builds + + +def RecordFailures(failure_dict, platform, suite, builder, int_date, log_file, + build_num, failed): + """Read and update the stored data about test failures.""" + + # Get the dictionary for this particular test suite from the failures + # dictionary. + suite_dict = failure_dict[suite] + + # Read in the entire log file for this test/build. + with open(log_file, 'r') as in_file: + lines = in_file.readlines() + + # Update the entries in the failure dictionary for each test within this suite + # that failed. + for test in failed: + # Check to see if there is already an entry in the suite dictionary for this + # test; if so use that, otherwise create a new entry. + if test in suite_dict: + test_dict = suite_dict[test] + else: + test_dict = dict() + # Parse the lines from the log file, looking for lines that indicate this + # test failed. + msg = '' + for l in lines: + words = l.split() + if len(words) < 3: + continue + if ((words[0] == test and words[1] == 'ERROR:') or + (words[0] == 'provision' and words[1] == 'FAIL:')): + words = words[2:] + # Get the error message for the failure. + msg = ' '.join(words) + if not msg: + msg = 'Unknown_Error' + + # Look for an existing entry for this error message in the test dictionary. + # If found use that, otherwise create a new entry for this error message. + if msg in test_dict: + error_list = test_dict[msg] + else: + error_list = list() + # Create an entry for this new failure + new_item = [int_date, platform, builder, build_num] + # Add this failure to the error list if it's not already there. + if new_item not in error_list: + error_list.append([int_date, platform, builder, build_num]) + # Sort the error list by date. + error_list.sort(key=lambda x: x[0]) + # Calculate the earliest date to save; delete records for older failures. + earliest_date = int_date - MAX_SAVE_RECORDS + i = 0 + while i < len(error_list) and error_list[i][0] <= earliest_date: + i += 1 + if i > 0: + error_list = error_list[i:] + # Save the error list in the test's dictionary, keyed on error_msg. + test_dict[msg] = error_list + + # Save the updated test dictionary in the test_suite dictionary. + suite_dict[test] = test_dict + + # Save the updated test_suite dictionary in the failure dictionary. + failure_dict[suite] = suite_dict + + +def ParseLogFile(log_file, test_data_dict, failure_dict, test, builder, + build_num, build_link): + """Parse the log file from the given builder, build_num and test. + + Also adds the results for this test to our test results dictionary, + and calls RecordFailures, to update our test failure data. + """ + + print('Parsing file %s' % log_file) + lines = [] + with open(log_file, 'r') as infile: + lines = infile.readlines() + + passed = {} + failed = {} + not_run = {} + date = '' + status = '' + board = '' + num_provision_errors = 0 + build_ok = True + afe_line = '' + + for line in lines: + if line.rstrip() == '<title>404 Not Found</title>': + print('Warning: File for %s (build number %d), %s was not found.' % + (builder, build_num, test)) + build_ok = False + break + if '[ PASSED ]' in line: + test_name = line.split()[0] + if test_name != 'Suite': + passed[test_name] = True + elif '[ FAILED ]' in line: + test_name = line.split()[0] + if test_name == 'provision': + num_provision_errors += 1 + not_run[test_name] = True + elif test_name != 'Suite': + failed[test_name] = True + elif line.startswith('started: '): + date = line.rstrip() + date = date[9:] + date_obj = time.strptime(date, '%a %b %d %H:%M:%S %Y') + int_date = ( + date_obj.tm_year * 10000 + date_obj.tm_mon * 100 + date_obj.tm_mday) + date = time.strftime('%a %b %d %Y', date_obj) + elif not status and line.startswith('status: '): + status = line.rstrip() + words = status.split(':') + status = words[-1] + elif line.find('Suite passed with a warning') != -1: + status = 'WARNING' + elif line.startswith('@@@STEP_LINK@Link to suite@'): + afe_line = line.rstrip() + words = afe_line.split('@') + for w in words: + if w.startswith('http'): + afe_line = w + afe_line = afe_line.replace('&', '&') + elif 'INFO: RunCommand:' in line: + words = line.split() + for i in range(0, len(words) - 1): + if words[i] == '--board': + board = words[i + 1] + + test_dict = test_data_dict[test] + test_list = test_dict['tests'] + + if build_ok: + for t in test_list: + if not t in passed and not t in failed: + not_run[t] = True + + total_pass = len(passed) + total_fail = len(failed) + total_notrun = len(not_run) + + else: + total_pass = 0 + total_fail = 0 + total_notrun = 0 + status = 'Not found.' + if not build_ok: + return [], date, board, 0, ' ' + + build_dict = dict() + build_dict['id'] = build_num + build_dict['builder'] = builder + build_dict['date'] = date + build_dict['build_link'] = build_link + build_dict['total_pass'] = total_pass + build_dict['total_fail'] = total_fail + build_dict['total_not_run'] = total_notrun + build_dict['afe_job_link'] = afe_line + build_dict['provision_errors'] = num_provision_errors + if status.strip() == 'SUCCESS': + build_dict['color'] = 'green ' + elif status.strip() == 'FAILURE': + build_dict['color'] = ' red ' + elif status.strip() == 'WARNING': + build_dict['color'] = 'orange' + else: + build_dict['color'] = ' ' + + # Use YYYYMMDD (integer) as the build record key + if build_ok: + if board in test_dict: + board_dict = test_dict[board] + else: + board_dict = dict() + board_dict[int_date] = build_dict + + # Only keep the last 5 records (based on date) + keys_list = board_dict.keys() + if len(keys_list) > MAX_SAVE_RECORDS: + min_key = min(keys_list) + del board_dict[min_key] + + # Make sure changes get back into the main dictionary + test_dict[board] = board_dict + test_data_dict[test] = test_dict + + if len(failed) > 0: + RecordFailures(failure_dict, board, test, builder, int_date, log_file, + build_num, failed) + + summary_result = '[%2d/ %2d/ %2d]' % (total_pass, total_fail, total_notrun) + + return summary_result, date, board, int_date, build_dict['color'] + + +def DownloadLogFile(builder, buildnum, test, test_family): + + ce = command_executer.GetCommandExecuter() + os.system('mkdir -p %s/%s/%s' % (DOWNLOAD_DIR, builder, test)) + if builder in ROTATING_BUILDERS: + source = ('https://uberchromegw.corp.google.com/i/chromiumos.tryserver' + '/builders/%s/builds/%d/steps/%s%%20%%5B%s%%5D/logs/stdio' % + (builder, buildnum, test_family, test)) + build_link = ('https://uberchromegw.corp.google.com/i/chromiumos.tryserver' + '/builders/%s/builds/%d' % (builder, buildnum)) + else: + source = ('https://uberchromegw.corp.google.com/i/chromeos/builders/%s/' + 'builds/%d/steps/%s%%20%%5B%s%%5D/logs/stdio' % + (builder, buildnum, test_family, test)) + build_link = ('https://uberchromegw.corp.google.com/i/chromeos/builders/%s' + '/builds/%d' % (builder, buildnum)) + + target = '%s/%s/%s/%d' % (DOWNLOAD_DIR, builder, test, buildnum) + if not os.path.isfile(target) or os.path.getsize(target) == 0: + cmd = 'sso_client %s > %s' % (source, target) + status = ce.RunCommand(cmd) + if status != 0: + return '', '' + + return target, build_link + + +# Check for prodaccess. +def CheckProdAccess(): + status, output, _ = command_executer.GetCommandExecuter().RunCommandWOutput( + 'prodcertstatus') + if status != 0: + return False + # Verify that status is not expired + if 'expires' in output: + return True + return False + + +def ValidOptions(parser, options): + too_many_options = False + if options.main: + if options.rotating or options.failures_report: + too_many_options = True + elif options.rotating and options.failures_report: + too_many_options = True + + if too_many_options: + parser.error('Can only specify one of --main, --rotating or' + ' --failures_report.') + + conflicting_failure_options = False + if options.failures_report and options.omit_failures: + conflicting_failure_options = True + parser.error('Cannot specify both --failures_report and --omit_failures.') + + email_ok = True + if options.email and options.email.find('@') == -1: + email_ok = False + parser.error('"%s" is not a valid email address; it must contain "@..."' % + options.email) + + return not too_many_options and not conflicting_failure_options and email_ok + + +def Main(argv): + """Main function for this script.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '--main', + dest='main', + default=False, + action='store_true', + help='Generate report only for main waterfall ' + 'builders.') + parser.add_argument( + '--rotating', + dest='rotating', + default=False, + action='store_true', + help='Generate report only for rotating builders.') + parser.add_argument( + '--failures_report', + dest='failures_report', + default=False, + action='store_true', + help='Only generate the failures section of the report.') + parser.add_argument( + '--omit_failures', + dest='omit_failures', + default=False, + action='store_true', + help='Do not generate the failures section of the report.') + parser.add_argument( + '--no_update', + dest='no_update', + default=False, + action='store_true', + help='Run reports, but do not update the data files.') + parser.add_argument( + '--date', + dest='date', + default=0, + type=int, + help='The date YYYYMMDD of waterfall report.') + parser.add_argument( + '--email', + dest='email', + default='', + help='Email address to use for sending the report.') + + options = parser.parse_args(argv) + + if not ValidOptions(parser, options): + return 1 + + main_only = options.main + rotating_only = options.rotating + failures_report = options.failures_report + omit_failures = options.omit_failures + date = options.date + + test_data_dict = dict() + failure_dict = dict() + + prod_access = CheckProdAccess() + if not prod_access: + print('ERROR: Please run prodaccess first.') + return + + with open('%s/waterfall-test-data.json' % DATA_DIR, 'r') as input_file: + test_data_dict = json.load(input_file) + + with open('%s/test-failure-data.json' % DATA_DIR, 'r') as fp: + failure_dict = json.load(fp) + + builds = GetBuilds(date) + + waterfall_report_dict = dict() + rotating_report_dict = dict() + int_date = 0 + for test_desc in TESTS: + test, test_family = test_desc + for build in builds: + (builder, buildnum) = build + if test.startswith('kernel') and 'llvm' in builder: + continue + if 'x86' in builder and not test.startswith('bvt'): + continue + target, build_link = DownloadLogFile(builder, buildnum, test, test_family) + + if os.path.exists(target): + test_summary, report_date, board, tmp_date, color = ParseLogFile( + target, test_data_dict, failure_dict, test, builder, buildnum, + build_link) + if not test_summary: + continue + + if tmp_date != 0: + int_date = tmp_date + + if builder in ROTATING_BUILDERS: + UpdateReport(rotating_report_dict, builder, test, report_date, + build_link, test_summary, board, color) + else: + UpdateReport(waterfall_report_dict, builder, test, report_date, + build_link, test_summary, board, color) + + PruneOldFailures(failure_dict, int_date) + + if options.email: + email_to = options.email + else: + email_to = getpass.getuser() + + if waterfall_report_dict and not rotating_only and not failures_report: + main_report = GenerateWaterfallReport(waterfall_report_dict, failure_dict, + 'main', int_date, omit_failures) + EmailReport(main_report, 'Main', format_date(int_date), email_to) + shutil.copy(main_report, ARCHIVE_DIR) + if rotating_report_dict and not main_only and not failures_report: + rotating_report = GenerateWaterfallReport( + rotating_report_dict, failure_dict, 'rotating', int_date, omit_failures) + EmailReport(rotating_report, 'Rotating', format_date(int_date), email_to) + shutil.copy(rotating_report, ARCHIVE_DIR) + + if failures_report: + failures_report = GenerateFailuresReport(failure_dict, int_date) + EmailReport(failures_report, 'Failures', format_date(int_date), email_to) + shutil.copy(failures_report, ARCHIVE_DIR) + + if not options.no_update: + with open('%s/waterfall-test-data.json' % DATA_DIR, 'w') as out_file: + json.dump(test_data_dict, out_file, indent=2) + + with open('%s/test-failure-data.json' % DATA_DIR, 'w') as out_file: + json.dump(failure_dict, out_file, indent=2) + + UpdateBuilds(builds) + + +if __name__ == '__main__': + Main(sys.argv[1:]) + sys.exit(0) diff --git a/deprecated/get_common_image_version.py b/deprecated/get_common_image_version.py new file mode 100755 index 00000000..4bb6949f --- /dev/null +++ b/deprecated/get_common_image_version.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python2 +# +# Copyright 2013 Google Inc. All Rights Reserved. +"""Script to find list of common images (first beta releases) in Chromeos. + +Display information about stable ChromeOS/Chrome versions to be used +by the team developers. The purpose is to increase team productivity +by using stable (known and tested) ChromeOS/Chrome versions instead of +using randomly selected versions. Currently we define as a "stable" +version the first Beta release in a particular release cycle. +""" + +from __future__ import print_function + +__author__ = 'llozano@google.com (Luis Lozano)' + +import argparse +import pickle +import re +import sys +import urllib + +VERSIONS_HISTORY_URL = 'http://cros-omahaproxy.appspot.com/history' + + +def DisplayBetas(betas): + print('List of betas from %s' % VERSIONS_HISTORY_URL) + for beta in betas: + print(' Release', beta['chrome_major_version'], beta) + return + + +def FindAllBetas(all_versions): + """Get ChromeOS first betas from History URL.""" + + all_betas = [] + prev_beta = {} + for line in all_versions: + match_obj = re.match( + r'(?P<date>.*),(?P<chromeos_version>.*),' + r'(?P<chrome_major_version>\d*).(?P<chrome_minor_version>.*),' + r'(?P<chrome_appid>.*),beta-channel,,Samsung Chromebook Series 5 550', + line) + if match_obj: + if prev_beta: + if (prev_beta['chrome_major_version'] != + match_obj.group('chrome_major_version')): + all_betas.append(prev_beta) + prev_beta = match_obj.groupdict() + if prev_beta: + all_betas.append(prev_beta) + return all_betas + + +def SerializeBetas(all_betas, serialize_file): + with open(serialize_file, 'wb') as f: + pickle.dump(all_betas, f) + print('Serialized list of betas into', serialize_file) + return + + +def Main(argv): + """Get ChromeOS first betas list from history URL.""" + + parser = argparse.ArgumentParser() + parser.add_argument( + '--serialize', + dest='serialize', + default=None, + help='Save list of common images into the specified ' + 'file.') + options = parser.parse_args(argv) + + try: + opener = urllib.URLopener() + all_versions = opener.open(VERSIONS_HISTORY_URL) + except IOError as ioe: + print('Cannot open', VERSIONS_HISTORY_URL) + print(ioe) + return 1 + + all_betas = FindAllBetas(all_versions) + DisplayBetas(all_betas) + if options.serialize: + SerializeBetas(all_betas, options.serialize) + all_versions.close() + + return 0 + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/mem_tests/README.md b/deprecated/mem_tests/README.md new file mode 100644 index 00000000..44bf16c9 --- /dev/null +++ b/deprecated/mem_tests/README.md @@ -0,0 +1,52 @@ +# Memory tests + +## Usage + +These scripts are made to parse TCMalloc output in order to extract certain +info from them. + +In particular, these scripts rely on the error logging system for ChromeOS in +order to extract information. In order to use a script (e.g. `total_mem.py`), +you just have the command: + +``` +./total_mem.py FILENAME +``` + +where `FILENAME` is the name of the log file to be parsed. + +## Codebase Changes + +There are two ideas that motivate these changes: + +1. Turn on TCMalloc sampling. +2. Use perf to collect the sample information. + + +The following files have to be changed: + +in `chrome/browser/metrics/perf_provider_chrome_os`, add: + +``` +#include "third_party/tcmalloc/chromium/src/gperftools/malloc_extension.h" +``` + +Change the perf profiling interval to something small (60*1000 milliseconds). + +Inside DoPeriodicCollection, insert the following code: + +``` +std::string output; +char* chr_arr = new char[9999]; +MallocExtension::instance() ->GetHeapSample(&output); +MallocExtension::instance() ->GetStats(chr_arr, 9999); +LOG(ERROR) << "Output Heap Data: "; +LOG(ERROR) << output; +LOG(ERROR) << "Output Heap Stats: "; +output = ""; +for (unsigned int i = 0; i < strlen(chr_arr); i++) { + output += chr_arr[i]; +} +LOG(ERROR) << output; +delete[] chr_arr; +``` diff --git a/deprecated/mem_tests/clean_data.py b/deprecated/mem_tests/clean_data.py new file mode 100755 index 00000000..1433ba41 --- /dev/null +++ b/deprecated/mem_tests/clean_data.py @@ -0,0 +1,29 @@ +#!/usr/bin/python2 +"""Cleans output from other scripts to eliminate duplicates. + +When frequently sampling data, we see that records occasionally will contain +the same timestamp (due to perf recording twice in the same second). + +This removes all of the duplicate timestamps for every record. Order with +respect to timestamps is not preserved. Also, the assumption is that the log +file is a csv with the first value in each row being the time in seconds from a +standard time. + +""" + +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument('filename') +args = parser.parse_args() + +my_file = open(args.filename) +output_file = open('clean2.csv', 'a') +dictionary = dict() + +for line in my_file: + new_time = int(line.split(',')[0]) + dictionary[new_time] = line + +for key in dictionary.keys(): + output_file.write(dictionary[key]) diff --git a/deprecated/mem_tests/mem_groups.py b/deprecated/mem_tests/mem_groups.py new file mode 100755 index 00000000..5d593872 --- /dev/null +++ b/deprecated/mem_tests/mem_groups.py @@ -0,0 +1,55 @@ +#!/usr/bin/python2 +"""Groups memory by allocation sizes. + +Takes a log entry and sorts sorts everything into groups based on what size +chunks the memory has been allocated in. groups is an array that contains the +divisions (in bytes). + +The output format is: + +timestamp, percent of memory in chunks < groups[0], percent between groups[0] +and groups[1], etc. + +""" + +import argparse +from cros_utils import compute_total_diff +from datetime import datetime + +pretty_print = True + +parser = argparse.ArgumentParser() +parser.add_argument('filename') +args = parser.parse_args() + +my_file = open(args.filename) +output_file = open('groups.csv', 'a') + +# The cutoffs for each group in the output (in bytes) +groups = [1024, 8192, 65536, 524288, 4194304] + +base_time = datetime(2014, 6, 11, 0, 0) +prev_line = '' +half_entry = (None, None) + +for line in my_file: + if 'heap profile:' in line: + if half_entry[0] is not None: + group_totals = half_entry[1] + total = sum(group_totals) * 1.0 + to_join = [half_entry[0]] + [value / total for value in group_totals] + to_output = ','.join([str(elem) for elem in to_join]) + output_file.write(to_output) + total_diff = compute_total_diff(line, base_time) + half_entry = (total_diff, [0] * (len(groups) + 1)) + if '] @ ' in line and 'heap profile:' not in line: + mem_samples = line.strip().split('[')[0] + num_samples, total_mem = map(int, mem_samples.strip().split(':')) + mem_per_sample = total_mem // num_samples + group_totals = half_entry[1] + for cutoff_index in range(len(groups)): + if mem_per_sample <= groups[cutoff_index]: + group_totals[cutoff_index] += total_mem + break + if mem_per_sample > groups[-1]: + group_totals[-1] += total_mem diff --git a/deprecated/mem_tests/total_mem_actual.py b/deprecated/mem_tests/total_mem_actual.py new file mode 100755 index 00000000..d2a0cedf --- /dev/null +++ b/deprecated/mem_tests/total_mem_actual.py @@ -0,0 +1,37 @@ +#!/usr/bin/python2 +"""Parses the actual memory usage from TCMalloc. + +This goes through logs that have the actual allocated memory (not sampled) in +the logs. The output is of the form of: + +time (in seconds from some base time), amount of memory allocated by the +application + +""" + +import argparse +from cros_utils import compute_total_diff +from datetime import datetime + +pretty_print = True + +parser = argparse.ArgumentParser() +parser.add_argument('filename') +args = parser.parse_args() + +my_file = open(args.filename) +output_file = open('raw_memory_data.csv', 'a') + +base_time = datetime(2014, 6, 11, 0, 0) +prev_line = '' +half_entry = (None, None) + +for line in my_file: + if 'Output Heap Stats:' in line: + total_diff = compute_total_diff(line, base_time) + half_entry = (total_diff, None) + if 'Bytes in use by application' in line: + total_diff = half_entry[0] + memory_used = int(line.strip().split()[1]) + half_entry = (None, None) + output_file.write('{0},{1}\n'.format(total_diff, memory_used)) diff --git a/deprecated/mem_tests/total_mem_sampled.py b/deprecated/mem_tests/total_mem_sampled.py new file mode 100755 index 00000000..32aa527c --- /dev/null +++ b/deprecated/mem_tests/total_mem_sampled.py @@ -0,0 +1,31 @@ +#!/usr/bin/python2 +"""Parses the total amount of sampled memory from log files. + +This file outputs the total amount of memory that has been sampled by tcmalloc. +The output is of the format: + +time in seconds from a base time, amount of memory that has been sampled + +""" + +import argparse +from cros_utils import compute_total_diff +from datetime import datetime + +parser = argparse.ArgumentParser() +parser.add_argument('filename') +args = parser.parse_args() + +my_file = open(args.filename) +output_file = open('memory_data.csv', 'a') + +base_time = datetime(2014, 6, 11, 0, 0) +prev_line = '' +half_entry = (None, None) + +for line in my_file: + if 'heap profile: ' not in line: + continue + memory_used = line.strip().split(':')[-1].strip().split(']')[0].strip() + total_diff = compute_total_diff(line, base_time) + output_file.write('{0},{1}\n'.format(int(total_diff), memory_used)) diff --git a/deprecated/mem_tests/utils.py b/deprecated/mem_tests/utils.py new file mode 100644 index 00000000..38bd89ca --- /dev/null +++ b/deprecated/mem_tests/utils.py @@ -0,0 +1,22 @@ +"""Utility functions for the memory tests. +""" + +from datetime import datetime + + +def compute_total_diff(line, base_time): + """ + Computes the difference in time the line was recorded from the base time. + + An example of a line is: + [4688:4688:0701/010151:ERROR:perf_provider_chromeos.cc(228)]... + + Here, the month is 07, the day is 01 and the time is 01:01:51. + + line- the line that contains the time the record was taken + base_time- the base time to measure our timestamp from + """ + date = line.strip().split(':')[2].split('/') + timestamp = datetime(2014, int(date[0][0:2]), int(date[0][2:4]), + int(date[1][0:2]), int(date[1][2:4]), int(date[1][4:6])) + return (timestamp - base_time).total_seconds() diff --git a/deprecated/new-generate-waterfall-reports.py b/deprecated/new-generate-waterfall-reports.py new file mode 100755 index 00000000..ef48f8be --- /dev/null +++ b/deprecated/new-generate-waterfall-reports.py @@ -0,0 +1,410 @@ +#!/usr/bin/env python2 +"""Generate summary report for ChromeOS toolchain waterfalls.""" + +from __future__ import print_function + +import argparse +import datetime +import getpass +import json +import os +import re +import shutil +import sys +import time + +from cros_utils import command_executer + +# All the test suites whose data we might want for the reports. +TESTS = (('bvt-inline', 'HWTest [bvt-inline]'), ('bvt-cq', 'HWTest [bvt-cq]'), + ('security', 'HWTest [security]')) + +# The main waterfall builders, IN THE ORDER IN WHICH WE WANT THEM +# LISTED IN THE REPORT. +WATERFALL_BUILDERS = [ + 'amd64-llvm-next-toolchain', + 'arm-llvm-next-toolchain', + 'arm64-llvm-next-toolchain', +] + +DATA_DIR = '/google/data/rw/users/mo/mobiletc-prebuild/waterfall-report-data/' +ARCHIVE_DIR = '/google/data/rw/users/mo/mobiletc-prebuild/waterfall-reports/' +DOWNLOAD_DIR = '/tmp/waterfall-logs' +MAX_SAVE_RECORDS = 7 +BUILD_DATA_FILE = '%s/build-data.txt' % DATA_DIR +LLVM_ROTATING_BUILDER = 'llvm_next_toolchain' +ROTATING_BUILDERS = [LLVM_ROTATING_BUILDER] + +# For int-to-string date conversion. Note, the index of the month in this +# list needs to correspond to the month's integer value. i.e. 'Sep' must +# be as MONTHS[9]. +MONTHS = [ + '', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', + 'Nov', 'Dec' +] + +DAYS_PER_MONTH = { + 1: 31, + 2: 28, + 3: 31, + 4: 30, + 5: 31, + 6: 30, + 7: 31, + 8: 31, + 9: 30, + 10: 31, + 11: 31, + 12: 31 +} + + +def format_date(int_date, use_int_month=False): + """Convert an integer date to a string date. YYYYMMDD -> YYYY-MMM-DD""" + + if int_date == 0: + return 'today' + + tmp_date = int_date + day = tmp_date % 100 + tmp_date = tmp_date / 100 + month = tmp_date % 100 + year = tmp_date / 100 + + if use_int_month: + date_str = '%d-%02d-%02d' % (year, month, day) + else: + month_str = MONTHS[month] + date_str = '%d-%s-%d' % (year, month_str, day) + return date_str + + +def EmailReport(report_file, report_type, date, email_to): + """Emails the report to the approprite address.""" + subject = '%s Waterfall Summary report, %s' % (report_type, date) + sendgmr_path = '/google/data/ro/projects/gws-sre/sendgmr' + command = ('%s --to=%s --subject="%s" --body_file=%s' % + (sendgmr_path, email_to, subject, report_file)) + command_executer.GetCommandExecuter().RunCommand(command) + + +def GetColor(status): + """Given a job status string, returns appropriate color string.""" + if status.strip() == 'pass': + color = 'green ' + elif status.strip() == 'fail': + color = ' red ' + elif status.strip() == 'warning': + color = 'orange' + else: + color = ' ' + return color + + +def GenerateWaterfallReport(report_dict, waterfall_type, date): + """Write out the actual formatted report.""" + + filename = 'waterfall_report.%s_waterfall.%s.txt' % (waterfall_type, date) + + date_string = '' + report_list = report_dict.keys() + + with open(filename, 'w') as out_file: + # Write Report Header + out_file.write('\nStatus of %s Waterfall Builds from %s\n\n' % + (waterfall_type, date_string)) + out_file.write(' \n') + out_file.write( + ' Build bvt- ' + ' bvt-cq ' + ' security \n') + out_file.write( + ' status inline ' + ' \n') + + # Write daily waterfall status section. + for builder in report_list: + build_dict = report_dict[builder] + buildbucket_id = build_dict['buildbucket_id'] + overall_status = build_dict['status'] + if 'bvt-inline' in build_dict.keys(): + inline_status = build_dict['bvt-inline'] + else: + inline_status = ' ' + if 'bvt-cq' in build_dict.keys(): + cq_status = build_dict['bvt-cq'] + else: + cq_status = ' ' + if 'security' in build_dict.keys(): + security_status = build_dict['security'] + else: + security_status = ' ' + inline_color = GetColor(inline_status) + cq_color = GetColor(cq_status) + security_color = GetColor(security_status) + + out_file.write( + '%26s %4s %6s %6s %6s\n' % + (builder, overall_status, inline_color, cq_color, security_color)) + if waterfall_type == 'main': + out_file.write(' build url: https://cros-goldeneye.corp.google.com/' + 'chromeos/healthmonitoring/buildDetails?buildbucketId=%s' + '\n' % buildbucket_id) + else: + out_file.write(' build url: https://ci.chromium.org/p/chromeos/' + 'builds/b%s \n' % buildbucket_id) + report_url = ('https://logs.chromium.org/v/?s=chromeos%2Fbuildbucket%2F' + 'cr-buildbucket.appspot.com%2F' + buildbucket_id + + '%2F%2B%2Fsteps%2FReport%2F0%2Fstdout') + out_file.write('\n report status url: %s\n' % report_url) + out_file.write('\n') + + print('Report generated in %s.' % filename) + return filename + + +def GetTryjobData(date, rotating_builds_dict): + """Read buildbucket id and board from stored file. + + buildbot_test_llvm.py, when it launches the rotating builders, + records the buildbucket_id and board for each launch in a file. + This reads that data out of the file so we can find the right + tryjob data. + """ + + date_str = format_date(date, use_int_month=True) + fname = '%s.builds' % date_str + filename = os.path.join(DATA_DIR, 'rotating-builders', fname) + + if not os.path.exists(filename): + print('Cannot find file: %s' % filename) + print('Unable to generate rotating builder report for date %d.' % date) + return + + with open(filename, 'r') as in_file: + lines = in_file.readlines() + + for line in lines: + l = line.strip() + parts = l.split(',') + if len(parts) != 2: + print('Warning: Illegal line in data file.') + print('File: %s' % filename) + print('Line: %s' % l) + continue + buildbucket_id = parts[0] + board = parts[1] + rotating_builds_dict[board] = buildbucket_id + + return + + +def GetRotatingBuildData(date, report_dict, chromeos_root, board, + buildbucket_id, ce): + """Gets rotating builder job results via 'cros buildresult'.""" + path = os.path.join(chromeos_root, 'chromite') + save_dir = os.getcwd() + date_str = format_date(date, use_int_month=True) + os.chdir(path) + + command = ( + 'cros buildresult --buildbucket-id %s --report json' % buildbucket_id) + _, out, _ = ce.RunCommandWOutput(command) + tmp_dict = json.loads(out) + results = tmp_dict[buildbucket_id] + + board_dict = dict() + board_dict['buildbucket_id'] = buildbucket_id + stages_results = results['stages'] + for test in TESTS: + key1 = test[0] + key2 = test[1] + if key2 in stages_results: + board_dict[key1] = stages_results[key2] + board_dict['status'] = results['status'] + report_dict[board] = board_dict + os.chdir(save_dir) + return + + +def GetMainWaterfallData(date, report_dict, chromeos_root, ce): + """Gets main waterfall job results via 'cros buildresult'.""" + path = os.path.join(chromeos_root, 'chromite') + save_dir = os.getcwd() + date_str = format_date(date, use_int_month=True) + os.chdir(path) + for builder in WATERFALL_BUILDERS: + command = ('cros buildresult --build-config %s --date %s --report json' % + (builder, date_str)) + _, out, _ = ce.RunCommandWOutput(command) + tmp_dict = json.loads(out) + builder_dict = dict() + for k in tmp_dict.keys(): + buildbucket_id = k + results = tmp_dict[k] + + builder_dict['buildbucket_id'] = buildbucket_id + builder_dict['status'] = results['status'] + stages_results = results['stages'] + for test in TESTS: + key1 = test[0] + key2 = test[1] + builder_dict[key1] = stages_results[key2] + report_dict[builder] = builder_dict + os.chdir(save_dir) + return + + +# Check for prodaccess. +def CheckProdAccess(): + """Verifies prodaccess is current.""" + status, output, _ = command_executer.GetCommandExecuter().RunCommandWOutput( + 'prodcertstatus') + if status != 0: + return False + # Verify that status is not expired + if 'expires' in output: + return True + return False + + +def ValidDate(date): + """Ensures 'date' is a valid date.""" + min_year = 2018 + + tmp_date = date + day = tmp_date % 100 + tmp_date = tmp_date / 100 + month = tmp_date % 100 + year = tmp_date / 100 + + if day < 1 or month < 1 or year < min_year: + return False + + cur_year = datetime.datetime.now().year + if year > cur_year: + return False + + if month > 12: + return False + + if month == 2 and cur_year % 4 == 0 and cur_year % 100 != 0: + max_day = 29 + else: + max_day = DAYS_PER_MONTH[month] + + if day > max_day: + return False + + return True + + +def ValidOptions(parser, options): + """Error-check the options passed to this script.""" + too_many_options = False + if options.main: + if options.rotating: + too_many_options = True + + if too_many_options: + parser.error('Can only specify one of --main, --rotating.') + + if not os.path.exists(options.chromeos_root): + parser.error( + 'Invalid chromeos root. Cannot find: %s' % options.chromeos_root) + + email_ok = True + if options.email and options.email.find('@') == -1: + email_ok = False + parser.error('"%s" is not a valid email address; it must contain "@..."' % + options.email) + + valid_date = ValidDate(options.date) + + return not too_many_options and valid_date and email_ok + + +def Main(argv): + """Main function for this script.""" + parser = argparse.ArgumentParser() + parser.add_argument( + '--main', + dest='main', + default=False, + action='store_true', + help='Generate report only for main waterfall ' + 'builders.') + parser.add_argument( + '--rotating', + dest='rotating', + default=False, + action='store_true', + help='Generate report only for rotating builders.') + parser.add_argument( + '--date', + dest='date', + required=True, + type=int, + help='The date YYYYMMDD of waterfall report.') + parser.add_argument( + '--email', + dest='email', + default='', + help='Email address to use for sending the report.') + parser.add_argument( + '--chromeos_root', + dest='chromeos_root', + required=True, + help='Chrome OS root in which to run chroot commands.') + + options = parser.parse_args(argv) + + if not ValidOptions(parser, options): + return 1 + + main_only = options.main + rotating_only = options.rotating + date = options.date + + prod_access = CheckProdAccess() + if not prod_access: + print('ERROR: Please run prodaccess first.') + return + + waterfall_report_dict = dict() + rotating_report_dict = dict() + + ce = command_executer.GetCommandExecuter() + if not rotating_only: + GetMainWaterfallData(date, waterfall_report_dict, options.chromeos_root, ce) + + if not main_only: + rotating_builds_dict = dict() + GetTryjobData(date, rotating_builds_dict) + if len(rotating_builds_dict.keys()) > 0: + for board in rotating_builds_dict.keys(): + buildbucket_id = rotating_builds_dict[board] + GetRotatingBuildData(date, rotating_report_dict, options.chromeos_root, + board, buildbucket_id, ce) + + if options.email: + email_to = options.email + else: + email_to = getpass.getuser() + + if waterfall_report_dict and not rotating_only: + main_report = GenerateWaterfallReport(waterfall_report_dict, 'main', date) + + EmailReport(main_report, 'Main', format_date(date), email_to) + shutil.copy(main_report, ARCHIVE_DIR) + if rotating_report_dict and not main_only: + rotating_report = GenerateWaterfallReport(rotating_report_dict, 'rotating', + date) + + EmailReport(rotating_report, 'Rotating', format_date(date), email_to) + shutil.copy(rotating_report, ARCHIVE_DIR) + + +if __name__ == '__main__': + Main(sys.argv[1:]) + sys.exit(0) diff --git a/deprecated/produce_output.py b/deprecated/produce_output.py new file mode 100755 index 00000000..46512c49 --- /dev/null +++ b/deprecated/produce_output.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""This simulates a real job by producing a lot of output.""" + +from __future__ import print_function + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import time + + +def Main(): + """The main function.""" + + for j in range(10): + for i in range(10000): + print(str(j) + 'The quick brown fox jumped over the lazy dog.' + str(i)) + time.sleep(60) + + return 0 + + +if __name__ == '__main__': + Main() diff --git a/deprecated/remote_gcc_build.py b/deprecated/remote_gcc_build.py new file mode 100755 index 00000000..edd0d2b6 --- /dev/null +++ b/deprecated/remote_gcc_build.py @@ -0,0 +1,479 @@ +#!/usr/bin/env python2 + +# Copyright (c) 2013 The Chromium OS Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. +"""Script to use remote try-bot build image with local gcc.""" + +from __future__ import print_function + +import argparse +import glob +import os +import re +import shutil +import socket +import sys +import tempfile +import time + +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import manifest_versions +from cros_utils import misc + +BRANCH = 'the_actual_branch_used_in_this_script' +TMP_BRANCH = 'tmp_branch' +SLEEP_TIME = 600 + +# pylint: disable=anomalous-backslash-in-string + + +def GetPatchNum(output): + lines = output.splitlines() + line = [l for l in lines if 'googlesource' in l][0] + patch_num = re.findall(r'\d+', line)[0] + if 'chrome-internal' in line: + patch_num = '*' + patch_num + return str(patch_num) + + +def GetPatchString(patch): + if patch: + return '+'.join(patch) + return 'NO_PATCH' + + +def FindVersionForToolchain(branch, chromeos_root): + """Find the version number in artifacts link in the tryserver email.""" + # For example: input: toolchain-3701.42.B + # output: R26-3701.42.1 + digits = branch.split('-')[1].split('B')[0] + manifest_dir = os.path.join(chromeos_root, 'manifest-internal') + os.chdir(manifest_dir) + major_version = digits.split('.')[0] + ce = command_executer.GetCommandExecuter() + command = 'repo sync . && git branch -a | grep {0}'.format(major_version) + _, branches, _ = ce.RunCommandWOutput(command, print_to_console=False) + m = re.search(r'(R\d+)', branches) + if not m: + logger.GetLogger().LogFatal('Cannot find version for branch {0}' + .format(branch)) + version = m.group(0) + '-' + digits + '1' + return version + + +def FindBuildId(description): + """Find the build id of the build at trybot server.""" + running_time = 0 + while True: + (result, number) = FindBuildIdFromLog(description) + if result >= 0: + return (result, number) + logger.GetLogger().LogOutput('{0} minutes passed.' + .format(running_time / 60)) + logger.GetLogger().LogOutput('Sleeping {0} seconds.'.format(SLEEP_TIME)) + time.sleep(SLEEP_TIME) + running_time += SLEEP_TIME + + +def FindBuildIdFromLog(description): + """Get the build id from build log.""" + # returns tuple (result, buildid) + # result == 0, buildid > 0, the build was successful and we have a build id + # result > 0, buildid > 0, the whole build failed for some reason but we + # do have a build id. + # result == -1, buildid == -1, we have not found a finished build for this + # description yet + + file_dir = os.path.dirname(os.path.realpath(__file__)) + commands = ('{0}/cros_utils/buildbot_json.py builds ' + 'http://chromegw/p/tryserver.chromiumos/'.format(file_dir)) + ce = command_executer.GetCommandExecuter() + _, buildinfo, _ = ce.RunCommandWOutput(commands, print_to_console=False) + + my_info = buildinfo.splitlines() + current_line = 1 + running_job = False + result = -1 + + # result == 0, we have a successful build + # result > 0, we have a failed build but build id may be valid + # result == -1, we have not found a finished build for this description + while current_line < len(my_info): + my_dict = {} + while True: + key = my_info[current_line].split(':')[0].strip() + value = my_info[current_line].split(':', 1)[1].strip() + my_dict[key] = value + current_line += 1 + if 'Build' in key or current_line == len(my_info): + break + if ('True' not in my_dict['completed'] and + str(description) in my_dict['reason']): + running_job = True + if ('True' not in my_dict['completed'] or + str(description) not in my_dict['reason']): + continue + result = int(my_dict['result']) + build_id = int(my_dict['number']) + if result == 0: + return (result, build_id) + else: + # Found a finished failed build. + # Keep searching to find a successful one + pass + + if result > 0 and not running_job: + return (result, build_id) + return (-1, -1) + + +def DownloadImage(target, index, dest, version): + """Download artifacts from cloud.""" + if not os.path.exists(dest): + os.makedirs(dest) + + rversion = manifest_versions.RFormatCrosVersion(version) + print(str(rversion)) + # ls_cmd = ("gsutil ls gs://chromeos-image-archive/trybot-{0}/{1}-b{2}" + # .format(target, rversion, index)) + ls_cmd = ('gsutil ls gs://chromeos-image-archive/trybot-{0}/*-b{2}'.format( + target, index)) + + download_cmd = ('$(which gsutil) cp {0} {1}'.format('{0}', dest)) + ce = command_executer.GetCommandExecuter() + + _, out, _ = ce.RunCommandWOutput(ls_cmd, print_to_console=True) + lines = out.splitlines() + download_files = [ + 'autotest.tar', 'chromeos-chrome', 'chromiumos_test_image', 'debug.tgz', + 'sysroot_chromeos-base_chromeos-chrome.tar.xz' + ] + for line in lines: + if any([e in line for e in download_files]): + cmd = download_cmd.format(line) + if ce.RunCommand(cmd): + logger.GetLogger().LogFatal('Command {0} failed, existing...' + .format(cmd)) + + +def UnpackImage(dest): + """Unpack the image, the chroot build dir.""" + chrome_tbz2 = glob.glob(dest + '/*.tbz2')[0] + commands = ('tar xJf {0}/sysroot_chromeos-base_chromeos-chrome.tar.xz ' + '-C {0} &&' + 'tar xjf {1} -C {0} &&' + 'tar xzf {0}/debug.tgz -C {0}/usr/lib/ &&' + 'tar xf {0}/autotest.tar -C {0}/usr/local/ &&' + 'tar xJf {0}/chromiumos_test_image.tar.xz -C {0}'.format( + dest, chrome_tbz2)) + ce = command_executer.GetCommandExecuter() + return ce.RunCommand(commands) + + +def RemoveOldBranch(): + """Remove the branch with name BRANCH.""" + ce = command_executer.GetCommandExecuter() + command = 'git rev-parse --abbrev-ref HEAD' + _, out, _ = ce.RunCommandWOutput(command) + if BRANCH in out: + command = 'git checkout -B {0}'.format(TMP_BRANCH) + ce.RunCommand(command) + command = "git commit -m 'nouse'" + ce.RunCommand(command) + command = 'git branch -D {0}'.format(BRANCH) + ce.RunCommand(command) + + +def UploadManifest(manifest, chromeos_root, branch='master'): + """Copy the manifest to $chromeos_root/manifest-internal and upload.""" + chromeos_root = misc.CanonicalizePath(chromeos_root) + manifest_dir = os.path.join(chromeos_root, 'manifest-internal') + os.chdir(manifest_dir) + ce = command_executer.GetCommandExecuter() + + RemoveOldBranch() + + if branch != 'master': + branch = '{0}'.format(branch) + command = 'git checkout -b {0} -t cros-internal/{1}'.format(BRANCH, branch) + ret = ce.RunCommand(command) + if ret: + raise RuntimeError('Command {0} failed'.format(command)) + + # We remove the default.xml, which is the symbolic link of full.xml. + # After that, we copy our xml file to default.xml. + # We did this because the full.xml might be updated during the + # run of the script. + os.remove(os.path.join(manifest_dir, 'default.xml')) + shutil.copyfile(manifest, os.path.join(manifest_dir, 'default.xml')) + return UploadPatch(manifest) + + +def GetManifestPatch(manifests, version, chromeos_root, branch='master'): + """Return a gerrit patch number given a version of manifest file.""" + temp_dir = tempfile.mkdtemp() + to_file = os.path.join(temp_dir, 'default.xml') + manifests.GetManifest(version, to_file) + return UploadManifest(to_file, chromeos_root, branch) + + +def UploadPatch(source): + """Up load patch to gerrit, return patch number.""" + commands = ('git add -A . &&' + "git commit -m 'test' -m 'BUG=None' -m 'TEST=None' " + "-m 'hostname={0}' -m 'source={1}'".format( + socket.gethostname(), source)) + ce = command_executer.GetCommandExecuter() + ce.RunCommand(commands) + + commands = ('yes | repo upload . --cbr --no-verify') + _, _, err = ce.RunCommandWOutput(commands) + return GetPatchNum(err) + + +def ReplaceSysroot(chromeos_root, dest_dir, target): + """Copy unpacked sysroot and image to chromeos_root.""" + ce = command_executer.GetCommandExecuter() + # get the board name from "board-release". board may contain "-" + board = target.rsplit('-', 1)[0] + board_dir = os.path.join(chromeos_root, 'chroot', 'build', board) + command = 'sudo rm -rf {0}'.format(board_dir) + ce.RunCommand(command) + + command = 'sudo mv {0} {1}'.format(dest_dir, board_dir) + ce.RunCommand(command) + + image_dir = os.path.join(chromeos_root, 'src', 'build', 'images', board, + 'latest') + command = 'rm -rf {0} && mkdir -p {0}'.format(image_dir) + ce.RunCommand(command) + + command = 'mv {0}/chromiumos_test_image.bin {1}'.format(board_dir, image_dir) + return ce.RunCommand(command) + + +def GccBranchForToolchain(branch): + if branch == 'toolchain-3428.65.B': + return 'release-R25-3428.B' + else: + return None + + +def GetGccBranch(branch): + """Get the remote branch name from branch or version.""" + ce = command_executer.GetCommandExecuter() + command = 'git branch -a | grep {0}'.format(branch) + _, out, _ = ce.RunCommandWOutput(command) + if not out: + release_num = re.match(r'.*(R\d+)-*', branch) + if release_num: + release_num = release_num.group(0) + command = 'git branch -a | grep {0}'.format(release_num) + _, out, _ = ce.RunCommandWOutput(command) + if not out: + GccBranchForToolchain(branch) + if not out: + out = 'remotes/cros/master' + new_branch = out.splitlines()[0] + return new_branch + + +def UploadGccPatch(chromeos_root, gcc_dir, branch): + """Upload local gcc to gerrit and get the CL number.""" + ce = command_executer.GetCommandExecuter() + gcc_dir = misc.CanonicalizePath(gcc_dir) + gcc_path = os.path.join(chromeos_root, 'src/third_party/gcc') + assert os.path.isdir(gcc_path), ('{0} is not a valid chromeos root' + .format(chromeos_root)) + assert os.path.isdir(gcc_dir), ('{0} is not a valid dir for gcc' + 'source'.format(gcc_dir)) + os.chdir(gcc_path) + RemoveOldBranch() + if not branch: + branch = 'master' + branch = GetGccBranch(branch) + command = ('git checkout -b {0} -t {1} && ' 'rm -rf *'.format(BRANCH, branch)) + ce.RunCommand(command, print_to_console=False) + + command = ("rsync -az --exclude='*.svn' --exclude='*.git'" + ' {0}/ .'.format(gcc_dir)) + ce.RunCommand(command) + return UploadPatch(gcc_dir) + + +def RunRemote(chromeos_root, branch, patches, is_local, target, chrome_version, + dest_dir): + """The actual running commands.""" + ce = command_executer.GetCommandExecuter() + + if is_local: + local_flag = '--local -r {0}'.format(dest_dir) + else: + local_flag = '--remote' + patch = '' + for p in patches: + patch += ' -g {0}'.format(p) + cbuildbot_path = os.path.join(chromeos_root, 'chromite/cbuildbot') + os.chdir(cbuildbot_path) + branch_flag = '' + if branch != 'master': + branch_flag = ' -b {0}'.format(branch) + chrome_version_flag = '' + if chrome_version: + chrome_version_flag = ' --chrome_version={0}'.format(chrome_version) + description = '{0}_{1}_{2}'.format(branch, GetPatchString(patches), target) + command = ('yes | ./cbuildbot {0} {1} {2} {3} {4} {5}' + ' --remote-description={6}' + ' --chrome_rev=tot'.format(patch, branch_flag, chrome_version, + local_flag, chrome_version_flag, target, + description)) + ce.RunCommand(command) + + return description + + +def Main(argv): + """The main function.""" + # Common initializations + parser = argparse.ArgumentParser() + parser.add_argument( + '-c', + '--chromeos_root', + required=True, + dest='chromeos_root', + help='The chromeos_root') + parser.add_argument( + '-g', '--gcc_dir', default='', dest='gcc_dir', help='The gcc dir') + parser.add_argument( + '-t', + '--target', + required=True, + dest='target', + help=('The target to be build, the list is at' + ' $(chromeos_root)/chromite/buildbot/cbuildbot' + ' --list -all')) + parser.add_argument('-l', '--local', action='store_true') + parser.add_argument( + '-d', + '--dest_dir', + dest='dest_dir', + help=('The dir to build the whole chromeos if' + ' --local is set')) + parser.add_argument( + '--chrome_version', + dest='chrome_version', + default='', + help='The chrome version to use. ' + 'Default it will use the latest one.') + parser.add_argument( + '--chromeos_version', + dest='chromeos_version', + default='', + help=('The chromeos version to use.' + '(1) A release version in the format: ' + "'\d+\.\d+\.\d+\.\d+.*'" + "(2) 'latest_lkgm' for the latest lkgm version")) + parser.add_argument( + '-r', + '--replace_sysroot', + action='store_true', + help=('Whether or not to replace the build/$board dir' + 'under the chroot of chromeos_root and copy ' + 'the image to src/build/image/$board/latest.' + ' Default is False')) + parser.add_argument( + '-b', + '--branch', + dest='branch', + default='', + help=('The branch to run trybot, default is None')) + parser.add_argument( + '-p', + '--patch', + dest='patch', + default='', + help=('The patches to be applied, the patches numbers ' + "be seperated by ','")) + + script_dir = os.path.dirname(os.path.realpath(__file__)) + + args = parser.parse_args(argv[1:]) + target = args.target + if args.patch: + patch = args.patch.split(',') + else: + patch = [] + chromeos_root = misc.CanonicalizePath(args.chromeos_root) + if args.chromeos_version and args.branch: + raise RuntimeError('You can not set chromeos_version and branch at the ' + 'same time.') + + manifests = None + if args.branch: + chromeos_version = '' + branch = args.branch + else: + chromeos_version = args.chromeos_version + manifests = manifest_versions.ManifestVersions() + if chromeos_version == 'latest_lkgm': + chromeos_version = manifests.TimeToVersion(time.mktime(time.gmtime())) + logger.GetLogger().LogOutput('found version %s for latest LKGM' % + (chromeos_version)) + # TODO: this script currently does not handle the case where the version + # is not in the "master" branch + branch = 'master' + + if chromeos_version: + manifest_patch = GetManifestPatch(manifests, chromeos_version, + chromeos_root) + patch.append(manifest_patch) + if args.gcc_dir: + # TODO: everytime we invoke this script we are getting a different + # patch for GCC even if GCC has not changed. The description should + # be based on the MD5 of the GCC patch contents. + patch.append(UploadGccPatch(chromeos_root, args.gcc_dir, branch)) + description = RunRemote(chromeos_root, branch, patch, args.local, target, + args.chrome_version, args.dest_dir) + if args.local or not args.dest_dir: + # TODO: We are not checktng the result of cbuild_bot in here! + return 0 + + # return value: + # 0 => build bot was successful and image was put where requested + # 1 => Build bot FAILED but image was put where requested + # 2 => Build bot failed or BUild bot was successful but and image was + # not generated or could not be put where expected + + os.chdir(script_dir) + dest_dir = misc.CanonicalizePath(args.dest_dir) + (bot_result, build_id) = FindBuildId(description) + if bot_result > 0 and build_id > 0: + logger.GetLogger().LogError('Remote trybot failed but image was generated') + bot_result = 1 + elif bot_result > 0: + logger.GetLogger().LogError('Remote trybot failed. No image was generated') + return 2 + if 'toolchain' in branch: + chromeos_version = FindVersionForToolchain(branch, chromeos_root) + assert not manifest_versions.IsRFormatCrosVersion(chromeos_version) + DownloadImage(target, build_id, dest_dir, chromeos_version) + ret = UnpackImage(dest_dir) + if ret != 0: + return 2 + # todo: return a more inteligent return value + if not args.replace_sysroot: + return bot_result + + ret = ReplaceSysroot(chromeos_root, args.dest_dir, target) + if ret != 0: + return 2 + + # got an image and we were successful in placing it where requested + return bot_result + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) diff --git a/deprecated/repo_to_repo.py b/deprecated/repo_to_repo.py new file mode 100755 index 00000000..91c5d580 --- /dev/null +++ b/deprecated/repo_to_repo.py @@ -0,0 +1,425 @@ +#!/usr/bin/env python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Module for transferring files between various types of repositories.""" + +from __future__ import print_function + +__author__ = 'asharif@google.com (Ahmad Sharif)' + +import argparse +import datetime +import json +import os +import re +import socket +import sys +import tempfile + +from automation.clients.helper import perforce +from cros_utils import command_executer +from cros_utils import logger +from cros_utils import misc + +# pylint: disable=anomalous-backslash-in-string + + +def GetCanonicalMappings(mappings): + canonical_mappings = [] + for mapping in mappings: + remote_path, local_path = mapping.split() + if local_path.endswith('/') and not remote_path.endswith('/'): + local_path = os.path.join(local_path, os.path.basename(remote_path)) + remote_path = remote_path.lstrip('/').split('/', 1)[1] + canonical_mappings.append(perforce.PathMapping(remote_path, local_path)) + return canonical_mappings + + +def SplitMapping(mapping): + parts = mapping.split() + assert len(parts) <= 2, 'Mapping %s invalid' % mapping + remote_path = parts[0] + if len(parts) == 2: + local_path = parts[1] + else: + local_path = '.' + return remote_path, local_path + + +class Repo(object): + """Basic repository base class.""" + + def __init__(self, no_create_tmp_dir=False): + self.repo_type = None + self.address = None + self.mappings = None + self.revision = None + self.ignores = ['.gitignore', '.p4config', 'README.google'] + if no_create_tmp_dir: + self._root_dir = None + else: + self._root_dir = tempfile.mkdtemp() + self._ce = command_executer.GetCommandExecuter() + self._logger = logger.GetLogger() + + def PullSources(self): + """Pull all sources into an internal dir.""" + pass + + def SetupForPush(self): + """Setup a repository for pushing later.""" + pass + + def PushSources(self, commit_message=None, dry_run=False, message_file=None): + """Push to the external repo with the commit message.""" + pass + + def _RsyncExcludingRepoDirs(self, source_dir, dest_dir): + for f in os.listdir(source_dir): + if f in ['.git', '.svn', '.p4config']: + continue + dest_file = os.path.join(dest_dir, f) + source_file = os.path.join(source_dir, f) + if os.path.exists(dest_file): + command = 'rm -rf %s' % dest_file + self._ce.RunCommand(command) + command = 'rsync -a %s %s' % (source_file, dest_dir) + self._ce.RunCommand(command) + return 0 + + def MapSources(self, dest_dir): + """Copy sources from the internal dir to root_dir.""" + return self._RsyncExcludingRepoDirs(self._root_dir, dest_dir) + + def GetRoot(self): + return self._root_dir + + def SetRoot(self, directory): + self._root_dir = directory + + def CleanupRoot(self): + command = 'rm -rf %s' % self._root_dir + return self._ce.RunCommand(command) + + def __str__(self): + return '\n'.join( + str(s) for s in [self.repo_type, self.address, self.mappings]) + + +# Note - this type of repo is used only for "readonly", in other words, this +# only serves as a incoming repo. +class FileRepo(Repo): + """Class for file repositories.""" + + def __init__(self, address, ignores=None): + Repo.__init__(self, no_create_tmp_dir=True) + self.repo_type = 'file' + self.address = address + self.mappings = None + self.branch = None + self.revision = '{0} (as of "{1}")'.format(address, datetime.datetime.now()) + self.gerrit = None + self._root_dir = self.address + if ignores: + self.ignores += ignores + + def CleanupRoot(self): + """Override to prevent deletion.""" + pass + + +class P4Repo(Repo): + """Class for P4 repositories.""" + + def __init__(self, address, mappings, revision=None): + Repo.__init__(self) + self.repo_type = 'p4' + self.address = address + self.mappings = mappings + self.revision = revision + + def PullSources(self): + client_name = socket.gethostname() + client_name += tempfile.mkstemp()[1].replace('/', '-') + mappings = self.mappings + p4view = perforce.View('depot2', GetCanonicalMappings(mappings)) + p4client = perforce.CommandsFactory( + self._root_dir, p4view, name=client_name) + command = p4client.SetupAndDo(p4client.Sync(self.revision)) + ret = self._ce.RunCommand(command) + assert ret == 0, 'Could not setup client.' + command = p4client.InCheckoutDir(p4client.SaveCurrentCLNumber()) + ret, o, _ = self._ce.RunCommandWOutput(command) + assert ret == 0, 'Could not get version from client.' + self.revision = re.search('^\d+$', o.strip(), re.MULTILINE).group(0) + command = p4client.InCheckoutDir(p4client.Remove()) + ret = self._ce.RunCommand(command) + assert ret == 0, 'Could not delete client.' + return 0 + + +class SvnRepo(Repo): + """Class for svn repositories.""" + + def __init__(self, address, mappings): + Repo.__init__(self) + self.repo_type = 'svn' + self.address = address + self.mappings = mappings + + def PullSources(self): + with misc.WorkingDirectory(self._root_dir): + for mapping in self.mappings: + remote_path, local_path = SplitMapping(mapping) + command = 'svn co %s/%s %s' % (self.address, remote_path, local_path) + ret = self._ce.RunCommand(command) + if ret: + return ret + + self.revision = '' + for mapping in self.mappings: + remote_path, local_path = SplitMapping(mapping) + command = 'cd %s && svnversion -c .' % (local_path) + ret, o, _ = self._ce.RunCommandWOutput(command) + self.revision += o.strip().split(':')[-1] + if ret: + return ret + return 0 + + +class GitRepo(Repo): + """Class for git repositories.""" + + def __init__(self, address, branch, mappings=None, ignores=None, gerrit=None): + Repo.__init__(self) + self.repo_type = 'git' + self.address = address + self.branch = branch or 'master' + if ignores: + self.ignores += ignores + self.mappings = mappings + self.gerrit = gerrit + + def _CloneSources(self): + with misc.WorkingDirectory(self._root_dir): + command = 'git clone %s .' % (self.address) + return self._ce.RunCommand(command) + + def PullSources(self): + with misc.WorkingDirectory(self._root_dir): + ret = self._CloneSources() + if ret: + return ret + + command = 'git checkout %s' % self.branch + ret = self._ce.RunCommand(command) + if ret: + return ret + + command = 'git describe --always' + ret, o, _ = self._ce.RunCommandWOutput(command) + self.revision = o.strip() + return ret + + def SetupForPush(self): + with misc.WorkingDirectory(self._root_dir): + ret = self._CloneSources() + logger.GetLogger().LogFatalIf( + ret, 'Could not clone git repo %s.' % self.address) + + command = 'git branch -a | grep -wq %s' % self.branch + ret = self._ce.RunCommand(command) + + if ret == 0: + if self.branch != 'master': + command = ('git branch --track %s remotes/origin/%s' % (self.branch, + self.branch)) + else: + command = 'pwd' + command += '&& git checkout %s' % self.branch + else: + command = 'git symbolic-ref HEAD refs/heads/%s' % self.branch + command += '&& rm -rf *' + ret = self._ce.RunCommand(command) + return ret + + def CommitLocally(self, commit_message=None, message_file=None): + with misc.WorkingDirectory(self._root_dir): + command = 'pwd' + for ignore in self.ignores: + command += '&& echo \'%s\' >> .git/info/exclude' % ignore + command += '&& git add -Av .' + if message_file: + message_arg = '-F %s' % message_file + elif commit_message: + message_arg = '-m \'%s\'' % commit_message + else: + raise RuntimeError('No commit message given!') + command += '&& git commit -v %s' % message_arg + return self._ce.RunCommand(command) + + def PushSources(self, commit_message=None, dry_run=False, message_file=None): + ret = self.CommitLocally(commit_message, message_file) + if ret: + return ret + push_args = '' + if dry_run: + push_args += ' -n ' + with misc.WorkingDirectory(self._root_dir): + if self.gerrit: + label = 'somelabel' + command = 'git remote add %s %s' % (label, self.address) + command += ('&& git push %s %s HEAD:refs/for/master' % (push_args, + label)) + else: + command = 'git push -v %s origin %s:%s' % (push_args, self.branch, + self.branch) + ret = self._ce.RunCommand(command) + return ret + + def MapSources(self, root_dir): + if not self.mappings: + self._RsyncExcludingRepoDirs(self._root_dir, root_dir) + return + with misc.WorkingDirectory(self._root_dir): + for mapping in self.mappings: + remote_path, local_path = SplitMapping(mapping) + remote_path.rstrip('...') + local_path.rstrip('...') + full_local_path = os.path.join(root_dir, local_path) + ret = self._RsyncExcludingRepoDirs(remote_path, full_local_path) + if ret: + return ret + return 0 + + +class RepoReader(object): + """Class for reading repositories.""" + + def __init__(self, filename): + self.filename = filename + self.main_dict = {} + self.input_repos = [] + self.output_repos = [] + + def ParseFile(self): + with open(self.filename) as f: + self.main_dict = json.load(f) + self.CreateReposFromDict(self.main_dict) + return [self.input_repos, self.output_repos] + + def CreateReposFromDict(self, main_dict): + for key, repo_list in main_dict.items(): + for repo_dict in repo_list: + repo = self.CreateRepoFromDict(repo_dict) + if key == 'input': + self.input_repos.append(repo) + elif key == 'output': + self.output_repos.append(repo) + else: + logger.GetLogger().LogFatal('Unknown key: %s found' % key) + + def CreateRepoFromDict(self, repo_dict): + repo_type = repo_dict.get('type', None) + repo_address = repo_dict.get('address', None) + repo_mappings = repo_dict.get('mappings', None) + repo_ignores = repo_dict.get('ignores', None) + repo_branch = repo_dict.get('branch', None) + gerrit = repo_dict.get('gerrit', None) + revision = repo_dict.get('revision', None) + + if repo_type == 'p4': + repo = P4Repo(repo_address, repo_mappings, revision=revision) + elif repo_type == 'svn': + repo = SvnRepo(repo_address, repo_mappings) + elif repo_type == 'git': + repo = GitRepo( + repo_address, + repo_branch, + mappings=repo_mappings, + ignores=repo_ignores, + gerrit=gerrit) + elif repo_type == 'file': + repo = FileRepo(repo_address) + else: + logger.GetLogger().LogFatal('Unknown repo type: %s' % repo_type) + return repo + + +@logger.HandleUncaughtExceptions +def Main(argv): + parser = argparse.ArgumentParser() + parser.add_argument( + '-i', + '--input_file', + dest='input_file', + help='The input file that contains repo descriptions.') + + parser.add_argument( + '-n', + '--dry_run', + dest='dry_run', + action='store_true', + default=False, + help='Do a dry run of the push.') + + parser.add_argument( + '-F', + '--message_file', + dest='message_file', + default=None, + help=('Use contents of the log file as the commit ' + 'message.')) + + options = parser.parse_args(argv) + if not options.input_file: + parser.print_help() + return 1 + rr = RepoReader(options.input_file) + [input_repos, output_repos] = rr.ParseFile() + + # Make sure FileRepo is not used as output destination. + for output_repo in output_repos: + if output_repo.repo_type == 'file': + logger.GetLogger().LogFatal( + 'FileRepo is only supported as an input repo.') + + for output_repo in output_repos: + ret = output_repo.SetupForPush() + if ret: + return ret + + input_revisions = [] + for input_repo in input_repos: + ret = input_repo.PullSources() + if ret: + return ret + input_revisions.append(input_repo.revision) + + for input_repo in input_repos: + for output_repo in output_repos: + ret = input_repo.MapSources(output_repo.GetRoot()) + if ret: + return ret + + commit_message = 'Synced repos to: %s' % ','.join(input_revisions) + for output_repo in output_repos: + ret = output_repo.PushSources( + commit_message=commit_message, + dry_run=options.dry_run, + message_file=options.message_file) + if ret: + return ret + + if not options.dry_run: + for output_repo in output_repos: + output_repo.CleanupRoot() + for input_repo in input_repos: + input_repo.CleanupRoot() + + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/test_gcc_dejagnu.py b/deprecated/test_gcc_dejagnu.py new file mode 100755 index 00000000..4ea0c51e --- /dev/null +++ b/deprecated/test_gcc_dejagnu.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python2 +# +# Copyright 2010 Google Inc. All Rights Reserved. +"""Script adapter used by automation client for testing dejagnu. + + This is not intended to be run on command line. + To kick off a single dejagnu run, use ./dejagnu/run_dejagnu.py +""" + +from __future__ import print_function + +__author__ = 'shenhan@google.com (Han Shen)' + +import argparse +import sys +import setup_chromeos +import build_tc + +from dejagnu import run_dejagnu +from cros_utils import command_executer +from cros_utils import email_sender + + +class DejagnuAdapter(object): + """Dejagnu Adapter class""" + + # TODO(shenhan): move these to constants.py. + _CHROMIUM_GCC_GIT = ('https://chromium.googlesource.com/' + 'chromiumos/third_party/gcc.git') + _CHROMIUM_GCC_BRANCH = 'gcc.gnu.org/branches/google/gcc-4_7-mobile' + + _cmd_exec = command_executer.GetCommandExecuter() + + def __init__(self, board, remote, gcc_dir, chromeos_root, runtestflags, + cleanup): + self._board = board + self._remote = remote + self._gcc_dir = gcc_dir + self._chromeos_root = chromeos_root + self._runtestflags = runtestflags + self._cleanup = cleanup + + def SetupChromeOS(self): + cmd = [ + setup_chromeos.__file__, '--dir=' + self._chromeos_root, '--minilayout', + '--jobs=8' + ] + ret = setup_chromeos.Main(cmd) + if ret: + raise RuntimeError('Failed to checkout chromeos') + ## Do cros_sdk and setup_board, otherwise build_tc in next step will fail. + cmd = 'cd {0} && cros_sdk --download'.format(self._chromeos_root) + ret = self._cmd_exec.RunCommand(cmd, terminated_timeout=9000) + if ret: + raise RuntimeError('Failed to create chroot.') + + def SetupBoard(self): + cmd = 'setup_board --board=' + self._board + ret = self._cmd_exec.ChrootRunCommand( + self._chromeos_root, cmd, terminated_timeout=4000) + if ret: + raise RuntimeError('Failed to setup board.') + + def CheckoutGCC(self): + cmd = 'git clone {0} {1} && cd {1} && git checkout {2}'.format( + self._CHROMIUM_GCC_GIT, self._gcc_dir, self._CHROMIUM_GCC_BRANCH) + + ret = self._cmd_exec.RunCommand(cmd, terminated_timeout=300) + if ret: + raise RuntimeError('Failed to checkout gcc.') + ## Handle build_tc bug. + cmd = ('touch {0}/gcc/config/arm/arm-tune.md ' + \ + '{0}/gcc/config/arm/arm-tables.opt').format(self._gcc_dir) + ret = self._cmd_exec.RunCommand(cmd) + + def BuildGCC(self): + build_gcc_args = [ + build_tc.__file__, '--board=' + self._board, + '--chromeos_root=' + self._chromeos_root, '--gcc_dir=' + self._gcc_dir + ] + ret = build_tc.Main(build_gcc_args) + if ret: + raise RuntimeError('Building gcc failed.') + + def CheckGCC(self): + args = [ + run_dejagnu.__file__, '--board=' + self._board, + '--chromeos_root=' + self._chromeos_root, '--mount=' + self._gcc_dir, + '--remote=' + self._remote + ] + if self._cleanup: + args.append('--cleanup=' + self._cleanup) + if self._runtestflags: + args.append('--flags=' + self._runtestflags) + return run_dejagnu.Main(args) + + +# Parse the output log to determine how many failures we have. +# Return -1 if parse output log failed. +def GetNumNewFailures(input_str): + if not input_str: + return 0 + start_counting = False + n_failures = 0 + for l in input_str.splitlines(): + print(l) + if not start_counting and 'Build results not in the manifest' in l: + start_counting = True + elif start_counting and l and (l.find('UNRESOLVED:') == 0 or + l.find('FAIL:') == 0 or l.find('XFAIL:') == 0 + or l.find('XPASS:') == 0): + n_failures = n_failures + 1 + if not start_counting: + return -1 + return n_failures + + +# Do not throw any exception in this function! +def EmailResult(result): + email_to = ['c-compiler-chrome@google.com'] + if len(result) == 4: + subject = 'Job failed: dejagnu test didn\'t finish' + email_text = 'Job failed prematurely, check exception below.\n' + \ + result[3] + elif result[0]: + subject = 'Job finished: dejagnu test failed' + num_new_failures = GetNumNewFailures(result[1]) + if num_new_failures >= 0: + summary = '{0} new fail(s), check log below.'.format(num_new_failures) + else: + summary = 'At least 1 new fail found, check log below.' + email_text = summary + \ + ('\nStdout ====\n' + '{0}\n' + '\nStderr ===\n' + '{1}\n').format(result[1], result[2]) + else: + subject = 'Job finished: dejagnu test passed' + email_text = ('Cool! No new fail found.\n' + '\nStdout ====\n' + '{0}\n' + '\nStderr ====\n' + '{1}\n').format(result[1], result[2]) + + try: + email_sender.EmailSender().SendEmail(email_to, subject, email_text) + print('Email sent.') + except Exception as e: + # Do not propagate this email sending exception, you want to email an + # email exception? Just log it on console. + print('Sending email failed - {0}' + 'Subject: {1}' + 'Text: {2}').format(str(e), subject, email_text) + + +def ProcessArguments(argv): + """Processing script arguments.""" + parser = argparse.ArgumentParser( + description=('This script is used by nightly client to test gcc. ' + 'DO NOT run it unless you know what you are doing.'), + usage='test_gcc_dejagnu.py options') + parser.add_argument( + '-b', + '--board', + dest='board', + help=('Required. Specify board type. For example ' + '\'lumpy\' and \'daisy\'')) + parser.add_argument( + '-r', + '--remote', + dest='remote', + help=('Required. Specify remote board address')) + parser.add_argument( + '-g', + '--gcc_dir', + dest='gcc_dir', + default='gcc.live', + help=('Optional. Specify gcc checkout directory.')) + parser.add_argument( + '-c', + '--chromeos_root', + dest='chromeos_root', + default='chromeos.live', + help=('Optional. Specify chromeos checkout directory.')) + parser.add_argument( + '--cleanup', + dest='cleanup', + default=None, + help=('Optional. Do cleanup after the test.')) + parser.add_argument( + '--runtestflags', + dest='runtestflags', + default=None, + help=('Optional. Options to RUNTESTFLAGS env var ' + 'while invoking make check. ' + '(Mainly used for testing purpose.)')) + + options = parser.parse_args(argv[1:]) + + if not options.board or not options.remote: + raise SyntaxError('--board and --remote are mandatory options.') + + return options + + +def Main(argv): + opt = ProcessArguments(argv) + adapter = DejagnuAdapter(opt.board, opt.remote, opt.gcc_dir, + opt.chromeos_root, opt.runtestflags, opt.cleanup) + try: + adapter.SetupChromeOS() + adapter.SetupBoard() + adapter.CheckoutGCC() + adapter.BuildGCC() + ret = adapter.CheckGCC() + except Exception as e: + print(e) + ret = (1, '', '', str(e)) + finally: + EmailResult(ret) + + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval[0]) diff --git a/deprecated/test_gdb_dejagnu.py b/deprecated/test_gdb_dejagnu.py new file mode 100755 index 00000000..6f37a4c9 --- /dev/null +++ b/deprecated/test_gdb_dejagnu.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python2 +"""Script adapter used by automation client for testing dejagnu. + + This is not intended to be run on command line. + To kick off a single dejagnu run, use ./dejagnu/run_dejagnu.py +""" + +from __future__ import print_function + +import argparse +import sys +import setup_chromeos + +from dejagnu import gdb_dejagnu +from cros_utils import command_executer +from cros_utils import email_sender + + +class DejagnuAdapter(object): + """Dejagnu Adapter class.""" + + def __init__(self, board, remote, gdb_dir, chromeos_root, cleanup): + self._board = board + self._remote = remote + self._gdb_dir = gdb_dir + self._chromeos_root = chromeos_root + self._cleanup = cleanup + self._cmd_exec = command_executer.GetCommandExecuter() + + def SetupChromeOS(self): + cmd = [ + setup_chromeos.__file__, '--dir=' + self._chromeos_root, '--minilayout', + '--jobs=8' + ] + ret = setup_chromeos.Main(cmd) + if ret: + raise RuntimeError('Failed to checkout chromeos') + ## Do cros_sdk and setup_board, otherwise build_tc in next step will fail. + cmd = 'cd {0} && cros_sdk --download'.format(self._chromeos_root) + ret = self._cmd_exec.RunCommand(cmd, terminated_timeout=9000) + if ret: + raise RuntimeError('Failed to create chroot.') + + def SetupBoard(self): + cmd = 'setup_board --board=' + self._board + ret = self._cmd_exec.ChrootRunCommand( + self._chromeos_root, cmd, terminated_timeout=4000) + if ret: + raise RuntimeError('Failed to setup board.') + + def CheckGDB(self): + args = [ + gdb_dejagnu.__file__, '--board=' + self._board, + '--chromeos_root=' + self._chromeos_root, '--mount=' + self._gdb_dir, + '--remote=' + self._remote + ] + if self._cleanup: + args.append('--cleanup=' + self._cleanup) + return gdb_dejagnu.Main(args) + + +# Parse the output log to determine how many failures we have. +# Return -1 if parse output log failed. +def GetNumNewFailures(result): + if not result: + return 0 + return len(result) + + +# Do not throw any exception in this function! +def EmailResult(result): + email_to = ['yunlian@google.com'] + if len(result) == 4: + subject = 'Job failed: dejagnu test didn\'t finish' + email_text = ( + 'Job failed prematurely, check exception below.\n' + result[3]) + elif result[0]: + subject = 'Job finished: dejagnu test failed' + num_new_failures = GetNumNewFailures(result[1]) + if num_new_failures >= 0: + summary = '{0} new fail(s), check log below.'.format(num_new_failures) + else: + summary = 'At least 1 new fail found, check log below.' + email_text = (summary + ('\nStdout ====\n' + '{0}\n' + '\nStderr ===\n' + '{1}\n').format(result[1], result[2])) + else: + subject = 'Job finished: dejagnu test passed' + email_text = ('Cool! No new fail found.\n' + '\nStdout ====\n' + '{0}\n' + '\nStderr ====\n' + '{1}\n').format(result[1], result[2]) + + try: + email_sender.EmailSender().SendEmail(email_to, subject, email_text) + print('Email sent.') + except Exception as e: + # Do not propagate this email sending exception, you want to email an + # email exception? Just log it on console. + print('Sending email failed - {0}' + 'Subject: {1}' + 'Text: {2}').format(str(e), subject, email_text) + + +def ProcessArguments(argv): + """Processing script arguments.""" + parser = argparse.ArgumentParser( + description=('This script is used by nightly client to test gdb. ' + 'DO NOT run it unless you know what you are doing.'), + usage='test_gdb_dejagnu.py options') + parser.add_argument( + '-b', + '--board', + dest='board', + help=('Required. Specify board type. For example ' + '\'lumpy\' and \'daisy\'')) + parser.add_argument( + '-r', + '--remote', + dest='remote', + help=('Required. Specify remote board address')) + parser.add_argument( + '-g', + '--gdb_dir', + dest='gdb_dir', + default='', + help=('Optional. Specify gdb checkout directory.')) + parser.add_argument( + '-c', + '--chromeos_root', + dest='chromeos_root', + default='chromeos.live', + help=('Optional. Specify chromeos checkout directory.')) + parser.add_argument( + '--cleanup', + dest='cleanup', + default=None, + help=('Optional. Do cleanup after the test.')) + + options = parser.parse_args(argv) + + if not options.board or not options.remote: + raise SyntaxError('--board and --remote are mandatory options.') + + return options + + +def Main(argv): + opt = ProcessArguments(argv) + print(opt) + adapter = DejagnuAdapter(opt.board, opt.remote, opt.gdb_dir, + opt.chromeos_root, opt.cleanup) + try: + adapter.SetupChromeOS() + adapter.SetupBoard() + ret = adapter.CheckGDB() + except Exception as e: + print(e) + ret = (1, '', '', str(e)) + finally: + EmailResult(ret) + + return ret + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval[0]) diff --git a/deprecated/test_toolchains.py b/deprecated/test_toolchains.py new file mode 100755 index 00000000..8684653f --- /dev/null +++ b/deprecated/test_toolchains.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python2 + +# Script to test different toolchains against ChromeOS benchmarks. +"""Toolchain team nightly performance test script (local builds).""" + +from __future__ import print_function + +import argparse +import datetime +import os +import sys +import build_chromeos +import setup_chromeos +from cros_utils import command_executer +from cros_utils import misc +from cros_utils import logger + +CROSTC_ROOT = '/usr/local/google/crostc' +MAIL_PROGRAM = '~/var/bin/mail-sheriff' +PENDING_ARCHIVES_DIR = os.path.join(CROSTC_ROOT, 'pending_archives') +NIGHTLY_TESTS_DIR = os.path.join(CROSTC_ROOT, 'nightly_test_reports') + + +class GCCConfig(object): + """GCC configuration class.""" + + def __init__(self, githash): + self.githash = githash + + +class ToolchainConfig(object): + """Toolchain configuration class.""" + + def __init__(self, gcc_config=None): + self.gcc_config = gcc_config + + +class ChromeOSCheckout(object): + """Main class for checking out, building and testing ChromeOS.""" + + def __init__(self, board, chromeos_root): + self._board = board + self._chromeos_root = chromeos_root + self._ce = command_executer.GetCommandExecuter() + self._l = logger.GetLogger() + self._build_num = None + + def _DeleteChroot(self): + command = 'cd %s; cros_sdk --delete' % self._chromeos_root + return self._ce.RunCommand(command) + + def _DeleteCcahe(self): + # crosbug.com/34956 + command = 'sudo rm -rf %s' % os.path.join(self._chromeos_root, '.cache') + return self._ce.RunCommand(command) + + def _GetBuildNumber(self): + """Get the build number of the ChromeOS image from the chroot. + + This function assumes a ChromeOS image has been built in the chroot. + It translates the 'latest' symlink in the + <chroot>/src/build/images/<board> directory, to find the actual + ChromeOS build number for the image that was built. For example, if + src/build/image/lumpy/latest -> R37-5982.0.2014_06_23_0454-a1, then + This function would parse it out and assign 'R37-5982' to self._build_num. + This is used to determine the official, vanilla build to use for + comparison tests. + """ + # Get the path to 'latest' + sym_path = os.path.join( + misc.GetImageDir(self._chromeos_root, self._board), 'latest') + # Translate the symlink to its 'real' path. + real_path = os.path.realpath(sym_path) + # Break up the path and get the last piece + # (e.g. 'R37-5982.0.2014_06_23_0454-a1" + path_pieces = real_path.split('/') + last_piece = path_pieces[-1] + # Break this piece into the image number + other pieces, and get the + # image number [ 'R37-5982', '0', '2014_06_23_0454-a1'] + image_parts = last_piece.split('.') + self._build_num = image_parts[0] + + def _BuildLabelName(self, config): + pieces = config.split('/') + compiler_version = pieces[-1] + label = compiler_version + '_tot_afdo' + return label + + def _BuildAndImage(self, label=''): + if (not label or + not misc.DoesLabelExist(self._chromeos_root, self._board, label)): + build_chromeos_args = [ + build_chromeos.__file__, '--chromeos_root=%s' % self._chromeos_root, + '--board=%s' % self._board, '--rebuild' + ] + if self._public: + build_chromeos_args.append('--env=USE=-chrome_internal') + + ret = build_chromeos.Main(build_chromeos_args) + if ret != 0: + raise RuntimeError("Couldn't build ChromeOS!") + + if not self._build_num: + self._GetBuildNumber() + # Check to see if we need to create the symbolic link for the vanilla + # image, and do so if appropriate. + if not misc.DoesLabelExist(self._chromeos_root, self._board, 'vanilla'): + build_name = '%s-release/%s.0.0' % (self._board, self._build_num) + full_vanilla_path = os.path.join(os.getcwd(), self._chromeos_root, + 'chroot/tmp', build_name) + misc.LabelLatestImage(self._chromeos_root, self._board, label, + full_vanilla_path) + else: + misc.LabelLatestImage(self._chromeos_root, self._board, label) + return label + + def _SetupBoard(self, env_dict, usepkg_flag, clobber_flag): + env_string = misc.GetEnvStringFromDict(env_dict) + command = ('%s %s' % (env_string, misc.GetSetupBoardCommand( + self._board, usepkg=usepkg_flag, force=clobber_flag))) + ret = self._ce.ChrootRunCommand(self._chromeos_root, command) + error_str = "Could not setup board: '%s'" % command + assert ret == 0, error_str + + def _UnInstallToolchain(self): + command = ('sudo CLEAN_DELAY=0 emerge -C cross-%s/gcc' % + misc.GetCtargetFromBoard(self._board, self._chromeos_root)) + ret = self._ce.ChrootRunCommand(self._chromeos_root, command) + if ret != 0: + raise RuntimeError("Couldn't uninstall the toolchain!") + + def _CheckoutChromeOS(self): + # TODO(asharif): Setup a fixed ChromeOS version (quarterly snapshot). + if not os.path.exists(self._chromeos_root): + setup_chromeos_args = ['--dir=%s' % self._chromeos_root] + if self._public: + setup_chromeos_args.append('--public') + ret = setup_chromeos.Main(setup_chromeos_args) + if ret != 0: + raise RuntimeError("Couldn't run setup_chromeos!") + + def _BuildToolchain(self, config): + # Call setup_board for basic, vanilla setup. + self._SetupBoard({}, usepkg_flag=True, clobber_flag=False) + # Now uninstall the vanilla compiler and setup/build our custom + # compiler. + self._UnInstallToolchain() + envdict = { + 'USE': 'git_gcc', + 'GCC_GITHASH': config.gcc_config.githash, + 'EMERGE_DEFAULT_OPTS': '--exclude=gcc' + } + self._SetupBoard(envdict, usepkg_flag=False, clobber_flag=False) + + +class ToolchainComparator(ChromeOSCheckout): + """Main class for running tests and generating reports.""" + + def __init__(self, + board, + remotes, + configs, + clean, + public, + force_mismatch, + noschedv2=False): + self._board = board + self._remotes = remotes + self._chromeos_root = 'chromeos' + self._configs = configs + self._clean = clean + self._public = public + self._force_mismatch = force_mismatch + self._ce = command_executer.GetCommandExecuter() + self._l = logger.GetLogger() + timestamp = datetime.datetime.strftime(datetime.datetime.now(), + '%Y-%m-%d_%H:%M:%S') + self._reports_dir = os.path.join( + NIGHTLY_TESTS_DIR, + '%s.%s' % (timestamp, board),) + self._noschedv2 = noschedv2 + ChromeOSCheckout.__init__(self, board, self._chromeos_root) + + def _FinishSetup(self): + # Get correct .boto file + current_dir = os.getcwd() + src = '/usr/local/google/home/mobiletc-prebuild/.boto' + dest = os.path.join(current_dir, self._chromeos_root, + 'src/private-overlays/chromeos-overlay/' + 'googlestorage_account.boto') + # Copy the file to the correct place + copy_cmd = 'cp %s %s' % (src, dest) + retv = self._ce.RunCommand(copy_cmd) + if retv != 0: + raise RuntimeError("Couldn't copy .boto file for google storage.") + + # Fix protections on ssh key + command = ('chmod 600 /var/cache/chromeos-cache/distfiles/target' + '/chrome-src-internal/src/third_party/chromite/ssh_keys' + '/testing_rsa') + retv = self._ce.ChrootRunCommand(self._chromeos_root, command) + if retv != 0: + raise RuntimeError('chmod for testing_rsa failed') + + def _TestLabels(self, labels): + experiment_file = 'toolchain_experiment.txt' + image_args = '' + if self._force_mismatch: + image_args = '--force-mismatch' + experiment_header = """ + board: %s + remote: %s + retries: 1 + """ % (self._board, self._remotes) + experiment_tests = """ + benchmark: all_toolchain_perf { + suite: telemetry_Crosperf + iterations: 3 + } + """ + + with open(experiment_file, 'w') as f: + f.write(experiment_header) + f.write(experiment_tests) + for label in labels: + # TODO(asharif): Fix crosperf so it accepts labels with symbols + crosperf_label = label + crosperf_label = crosperf_label.replace('-', '_') + crosperf_label = crosperf_label.replace('+', '_') + crosperf_label = crosperf_label.replace('.', '') + + # Use the official build instead of building vanilla ourselves. + if label == 'vanilla': + build_name = '%s-release/%s.0.0' % (self._board, self._build_num) + + # Now add 'official build' to test file. + official_image = """ + official_image { + chromeos_root: %s + build: %s + } + """ % (self._chromeos_root, build_name) + f.write(official_image) + + else: + experiment_image = """ + %s { + chromeos_image: %s + image_args: %s + } + """ % (crosperf_label, os.path.join( + misc.GetImageDir(self._chromeos_root, self._board), label, + 'chromiumos_test_image.bin'), image_args) + f.write(experiment_image) + + crosperf = os.path.join(os.path.dirname(__file__), 'crosperf', 'crosperf') + noschedv2_opts = '--noschedv2' if self._noschedv2 else '' + command = ('{crosperf} --no_email=True --results_dir={r_dir} ' + '--json_report=True {noschedv2_opts} {exp_file}').format( + crosperf=crosperf, + r_dir=self._reports_dir, + noschedv2_opts=noschedv2_opts, + exp_file=experiment_file) + + ret = self._ce.RunCommand(command) + if ret != 0: + raise RuntimeError('Crosperf execution error!') + else: + # Copy json report to pending archives directory. + command = 'cp %s/*.json %s/.' % (self._reports_dir, PENDING_ARCHIVES_DIR) + ret = self._ce.RunCommand(command) + return + + def _SendEmail(self): + """Find email msesage generated by crosperf and send it.""" + filename = os.path.join(self._reports_dir, 'msg_body.html') + if (os.path.exists(filename) and + os.path.exists(os.path.expanduser(MAIL_PROGRAM))): + command = ('cat %s | %s -s "Nightly test results, %s" -team -html' % + (filename, MAIL_PROGRAM, self._board)) + self._ce.RunCommand(command) + + def DoAll(self): + self._CheckoutChromeOS() + labels = [] + labels.append('vanilla') + for config in self._configs: + label = self._BuildLabelName(config.gcc_config.githash) + if not misc.DoesLabelExist(self._chromeos_root, self._board, label): + self._BuildToolchain(config) + label = self._BuildAndImage(label) + labels.append(label) + self._FinishSetup() + self._TestLabels(labels) + self._SendEmail() + if self._clean: + ret = self._DeleteChroot() + if ret != 0: + return ret + ret = self._DeleteCcahe() + if ret != 0: + return ret + return 0 + + +def Main(argv): + """The main function.""" + # Common initializations + ### command_executer.InitCommandExecuter(True) + command_executer.InitCommandExecuter() + parser = argparse.ArgumentParser() + parser.add_argument( + '--remote', dest='remote', help='Remote machines to run tests on.') + parser.add_argument( + '--board', dest='board', default='x86-alex', help='The target board.') + parser.add_argument( + '--githashes', + dest='githashes', + default='master', + help='The gcc githashes to test.') + parser.add_argument( + '--clean', + dest='clean', + default=False, + action='store_true', + help='Clean the chroot after testing.') + parser.add_argument( + '--public', + dest='public', + default=False, + action='store_true', + help='Use the public checkout/build.') + parser.add_argument( + '--force-mismatch', + dest='force_mismatch', + default='', + help='Force the image regardless of board mismatch') + parser.add_argument( + '--noschedv2', + dest='noschedv2', + action='store_true', + default=False, + help='Pass --noschedv2 to crosperf.') + options = parser.parse_args(argv) + if not options.board: + print('Please give a board.') + return 1 + if not options.remote: + print('Please give at least one remote machine.') + return 1 + toolchain_configs = [] + for githash in options.githashes.split(','): + gcc_config = GCCConfig(githash=githash) + toolchain_config = ToolchainConfig(gcc_config=gcc_config) + toolchain_configs.append(toolchain_config) + fc = ToolchainComparator(options.board, options.remote, toolchain_configs, + options.clean, options.public, + options.force_mismatch, options.noschedv2) + return fc.DoAll() + + +if __name__ == '__main__': + retval = Main(sys.argv[1:]) + sys.exit(retval) diff --git a/deprecated/verify_compiler.py b/deprecated/verify_compiler.py new file mode 100755 index 00000000..b70c1257 --- /dev/null +++ b/deprecated/verify_compiler.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python2 +"""Verify that a ChromeOS sub-tree was built with a particular compiler""" + +from __future__ import print_function + +import argparse +import fnmatch +import os +import sys + +from cros_utils import command_executer + +COMPILERS = ['gcc', 'clang'] + +COMPILER_STRINGS = {'gcc': 'GNU C', 'clang': 'clang version'} + +ERR_NO_DEBUG_INFO = 1024 + + +def UsageError(parser, message): + """Output error message and help/usage info.""" + + print('ERROR: %s' % message) + parser.print_help() + sys.exit(0) + + +def CreateTmpDwarfFile(filename, dwarf_file, cmd_executer): + """Create temporary dwarfdump file, to be parsed later.""" + + cmd = ('readelf --debug-dump=info %s | grep -A5 DW_AT_producer > %s' % + (filename, dwarf_file)) + retval = cmd_executer.RunCommand(cmd, print_to_console=False) + return retval + + +def FindAllFiles(root_dir): + """Create a list of all the *.debug and *.dwp files to be checked.""" + + file_list = [] + tmp_list = [ + os.path.join(dirpath, f) + for dirpath, _, files in os.walk(root_dir) + for f in fnmatch.filter(files, '*.debug') + ] + for f in tmp_list: + if 'build-id' not in f: + file_list.append(f) + tmp_list = [ + os.path.join(dirpath, f) + for dirpath, _, files in os.walk(root_dir) + for f in fnmatch.filter(files, '*.dwp') + ] + file_list += tmp_list + return file_list + + +def VerifyArgs(compiler, filename, tmp_dir, root_dir, options, parser): + """Verify that the option values and combinations are valid.""" + + if options.filename and options.all_files: + UsageError(parser, 'Cannot use both --file and --all_files.') + if options.filename and options.root_dir: + UsageError(parser, 'Cannot use both --file and --root_dir.') + if options.all_files and not options.root_dir: + UsageError(parser, 'Missing --root_dir option.') + if options.root_dir and not options.all_files: + UsageError(parser, 'Missing --all_files option.') + if not options.filename and not options.all_files: + UsageError(parser, 'Must specify either --file or --all_files.') + + # Verify that the values specified are valid. + if filename: + if not os.path.exists(filename): + UsageError(parser, 'Cannot find %s' % filename) + compiler = options.compiler.lower() + if compiler not in COMPILERS: + UsageError(parser, '%s is not a valid compiler (gcc or clang).' % compiler) + if root_dir and not os.path.exists(root_dir): + UsageError(parser, '%s does not exist.' % root_dir) + if not os.path.exists(tmp_dir): + os.makedirs(tmp_dir) + + +def CheckFile(filename, compiler, tmp_dir, options, cmd_executer): + """Verify the information in a single file.""" + + print('Checking %s' % filename) + # Verify that file contains debug information. + cmd = 'readelf -SW %s | grep debug_info' % filename + retval = cmd_executer.RunCommand(cmd, print_to_console=False) + if retval != 0: + print('No debug info in this file. Unable to verify compiler.') + # There's no debug info in this file, so skip it. + return ERR_NO_DEBUG_INFO + + tmp_name = os.path.basename(filename) + '.dwarf' + dwarf_file = os.path.join(tmp_dir, tmp_name) + status = CreateTmpDwarfFile(filename, dwarf_file, cmd_executer) + + if status != 0: + print('Unable to create dwarf file for %s (status: %d).' % (filename, + status)) + return status + + comp_str = COMPILER_STRINGS[compiler] + + retval = 0 + with open(dwarf_file, 'r') as in_file: + lines = in_file.readlines() + looking_for_name = False + for line in lines: + if 'DW_AT_producer' in line: + looking_for_name = False + if 'GNU AS' in line: + continue + if comp_str not in line: + looking_for_name = True + retval = 1 + elif looking_for_name: + if 'DW_AT_name' in line: + words = line.split(':') + bad_file = words[-1] + print('FAIL: %s was not compiled with %s.' % (bad_file.rstrip(), + compiler)) + looking_for_name = False + elif 'DW_TAG_' in line: + looking_for_name = False + + if not options.keep_file: + os.remove(dwarf_file) + + return retval + + +def Main(argv): + + cmd_executer = command_executer.GetCommandExecuter() + parser = argparse.ArgumentParser() + parser.add_argument( + '--file', dest='filename', help='Name of file to be verified.') + parser.add_argument( + '--compiler', + dest='compiler', + required=True, + help='Desired compiler (gcc or clang)') + parser.add_argument( + '--tmp_dir', + dest='tmp_dir', + help='Directory in which to put dwarf dump file.' + ' Defaults to /tmp') + parser.add_argument( + '--keep_file', + dest='keep_file', + default=False, + action='store_true', + help='Do not delete dwarf file when done.') + parser.add_argument( + '--all_files', + dest='all_files', + default=False, + action='store_true', + help='Find and check ALL .debug/.dwp files ' + 'in subtree. Must be used with --root_dir ' + '(and NOT with --file).') + parser.add_argument( + '--root_dir', + dest='root_dir', + help='Root of subtree in which to look for ' + 'files. Must be used with --all_files, and' + ' not with --file.') + + options = parser.parse_args(argv) + + compiler = options.compiler + filename = None + if options.filename: + filename = os.path.realpath(os.path.expanduser(options.filename)) + tmp_dir = '/tmp' + if options.tmp_dir: + tmp_dir = os.path.realpath(os.path.expanduser(options.tmp_dir)) + root_dir = None + if options.root_dir: + root_dir = os.path.realpath(os.path.expanduser(options.root_dir)) + + VerifyArgs(compiler, filename, tmp_dir, root_dir, options, parser) + + file_list = [] + if filename: + file_list.append(filename) + else: + file_list = FindAllFiles(root_dir) + + bad_files = [] + unknown_files = [] + all_pass = True + for f in file_list: + result = CheckFile(f, compiler, tmp_dir, options, cmd_executer) + if result == ERR_NO_DEBUG_INFO: + unknown_files.append(f) + all_pass = False + elif result != 0: + bad_files.append(f) + all_pass = False + + if all_pass: + print('\n\nSUCCESS: All compilation units were compiled with %s.\n' % + compiler) + return 0 + else: + if len(bad_files) == 0: + print( + '\n\n*Mostly* SUCCESS: All files that could be checked were compiled ' + 'with %s.' % compiler) + print( + '\n\nUnable to verify the following files (no debug info in them):\n') + for f in unknown_files: + print(f) + else: + print('\n\nFAILED: The following files were not compiled with %s:\n' % + compiler) + for f in bad_files: + print(f) + if len(unknown_files) > 0: + print('\n\nUnable to verify the following files (no debug info in ' + 'them):\n') + for f in unknown_files: + print(f) + return 1 + + +if __name__ == '__main__': + sys.exit(Main(sys.argv[1:])) diff --git a/deprecated/weekly_report.py b/deprecated/weekly_report.py new file mode 100755 index 00000000..476b9f0d --- /dev/null +++ b/deprecated/weekly_report.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +# +# Copyright Google Inc. 2014 + +"""Module to generate the 7-day crosperf reports.""" + +from __future__ import print_function + +import argparse +import datetime +import os +import sys + +from cros_utils import constants +from cros_utils import command_executer + +WEEKDAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] +DATA_ROOT_DIR = os.path.join(constants.CROSTC_WORKSPACE, 'weekly_test_data') +EXPERIMENT_FILE = os.path.join(DATA_ROOT_DIR, 'weekly_report') +MAIL_PROGRAM = '~/var/bin/mail-sheriff' + + +def Generate_Vanilla_Report_File(vanilla_image_paths, board, remote, + chromeos_root, cmd_executer): + + experiment_header = """ +name: weekly_vanilla_report +cache_only: True +same_specs: False +board: %s +remote: %s +""" % (board, remote) + + experiment_tests = """ +benchmark: all_toolchain_perf { + suite: telemetry_Crosperf + iterations: 3 +} +""" + + filename = '%s_%s_vanilla.exp' % (EXPERIMENT_FILE, board) + if os.path.exists(filename): + cmd = 'rm %s' % filename + cmd_executer.RunCommand(cmd) + + with open(filename, 'w') as f: + f.write(experiment_header) + f.write(experiment_tests) + + # Add each vanilla image + for test_path in vanilla_image_paths: + pieces = test_path.split('/') + test_name = pieces[-1] + test_image = """ +%s { + chromeos_root: %s + chromeos_image: %s +} +""" % (test_name, chromeos_root, + os.path.join(test_path, 'chromiumos_test_image.bin')) + f.write(test_image) + + return filename + + +def Generate_Test_File(test_image_paths, vanilla_image_path, board, remote, + chromeos_root, cmd_executer): + + experiment_header = """ +name: weekly_report +cache_only: True +same_specs: False +board: %s +remote: %s +""" % (board, remote) + + experiment_tests = """ +benchmark: all_toolchain_perf { + suite: telemetry_Crosperf + iterations: 3 +} +""" + + filename = '%s_%s.exp' % (EXPERIMENT_FILE, board) + if os.path.exists(filename): + cmd = 'rm %s' % filename + cmd_executer.RunCommand(cmd) + + with open(filename, 'w') as f: + f.write(experiment_header) + f.write(experiment_tests) + + # Add vanilla image (first) + vanilla_image = """ +%s { + chromeos_root: %s + chromeos_image: %s +} +""" % (vanilla_image_path.split('/')[-1], chromeos_root, + os.path.join(vanilla_image_path, 'chromiumos_test_image.bin')) + + f.write(vanilla_image) + + # Add each test image + for test_path in test_image_paths: + pieces = test_path.split('/') + test_name = pieces[-1] + test_image = """ +%s { + chromeos_root: %s + chromeos_image: %s +} +""" % (test_name, chromeos_root, + os.path.join(test_path, 'chromiumos_test_image.bin')) + f.write(test_image) + + return filename + + +def Main(argv): + + parser = argparse.ArgumentParser() + parser.add_argument('-b', '--board', dest='board', help='Target board.') + parser.add_argument('-r', '--remote', dest='remote', help='Target device.') + parser.add_argument( + '-v', + '--vanilla_only', + dest='vanilla_only', + action='store_true', + default=False, + help='Generate a report comparing only the vanilla ' + 'images.') + + options = parser.parse_args(argv[1:]) + + if not options.board: + print('Must specify a board.') + return 1 + + if not options.remote: + print('Must specify at least one remote.') + return 1 + + cmd_executer = command_executer.GetCommandExecuter(log_level='average') + + # Find starting index, for cycling through days of week, generating + # reports starting 6 days ago from today. Generate list of indices for + # order in which to look at weekdays for report: + todays_index = datetime.datetime.today().isoweekday() + indices = [] + start = todays_index + 1 + end = start + 7 + for i in range(start, end): + indices.append(i % 7) + # E.g. if today is Sunday, then start report with last Monday, so + # indices = [1, 2, 3, 4, 5, 6, 0]. + + # Find all the test image tar files, untar them and add them to + # the list. Also find and untar vanilla image tar files, and keep + # track of the first vanilla image. + report_image_paths = [] + vanilla_image_paths = [] + first_vanilla_image = None + for i in indices: + day = WEEKDAYS[i] + data_path = os.path.join(DATA_ROOT_DIR, options.board, day) + if os.path.exists(data_path): + # First, untar the test image. + tar_file_name = '%s_test_image.tar' % day + tar_file_path = os.path.join(data_path, tar_file_name) + image_dir = '%s_test_image' % day + image_path = os.path.join(data_path, image_dir) + if os.path.exists(tar_file_path): + if not os.path.exists(image_path): + os.makedirs(image_path) + cmd = ('cd %s; tar -xvf %s -C %s --strip-components 1' % + (data_path, tar_file_path, image_path)) + ret = cmd_executer.RunCommand(cmd) + if not ret: + report_image_paths.append(image_path) + # Next, untar the vanilla image. + vanilla_file = '%s_vanilla_image.tar' % day + v_file_path = os.path.join(data_path, vanilla_file) + image_dir = '%s_vanilla_image' % day + image_path = os.path.join(data_path, image_dir) + if os.path.exists(v_file_path): + if not os.path.exists(image_path): + os.makedirs(image_path) + cmd = ('cd %s; tar -xvf %s -C %s --strip-components 1' % + (data_path, v_file_path, image_path)) + ret = cmd_executer.RunCommand(cmd) + if not ret: + vanilla_image_paths.append(image_path) + if not first_vanilla_image: + first_vanilla_image = image_path + + # Find a chroot we can use. Look for a directory containing both + # an experiment file and a chromeos directory (the experiment file will + # only be created if both images built successfully, i.e. the chroot is + # good). + chromeos_root = None + timestamp = datetime.datetime.strftime(datetime.datetime.now(), + '%Y-%m-%d_%H:%M:%S') + results_dir = os.path.join( + os.path.expanduser('~/nightly_test_reports'), + '%s.%s' % (timestamp, options.board), 'weekly_tests') + + for day in WEEKDAYS: + startdir = os.path.join(constants.CROSTC_WORKSPACE, 'nightly-tests', day) + num_dirs = os.listdir(startdir) + for d in num_dirs: + exp_file = os.path.join(startdir, d, 'toolchain_experiment.txt') + chroot = os.path.join(startdir, d, 'chromeos') + if os.path.exists(chroot) and os.path.exists(exp_file): + chromeos_root = chroot + if chromeos_root: + break + if chromeos_root: + break + + if not chromeos_root: + print('Unable to locate a usable chroot. Exiting without report.') + return 1 + + # Create the Crosperf experiment file for generating the weekly report. + if not options.vanilla_only: + filename = Generate_Test_File(report_image_paths, first_vanilla_image, + options.board, options.remote, chromeos_root, + cmd_executer) + else: + filename = Generate_Vanilla_Report_File(vanilla_image_paths, options.board, + options.remote, chromeos_root, + cmd_executer) + + # Run Crosperf on the file to generate the weekly report. + cmd = ('%s/toolchain-utils/crosperf/crosperf ' + '%s --no_email=True --results_dir=%s' % (constants.CROSTC_WORKSPACE, + filename, results_dir)) + retv = cmd_executer.RunCommand(cmd) + if retv == 0: + # Send the email, if the crosperf command worked. + filename = os.path.join(results_dir, 'msg_body.html') + if (os.path.exists(filename) and + os.path.exists(os.path.expanduser(MAIL_PROGRAM))): + vanilla_string = ' ' + if options.vanilla_only: + vanilla_string = ' Vanilla ' + command = ('cat %s | %s -s "Weekly%sReport results, %s" -team -html' % + (filename, MAIL_PROGRAM, vanilla_string, options.board)) + retv = cmd_executer.RunCommand(command) + + return retv + + +if __name__ == '__main__': + retval = Main(sys.argv) + sys.exit(retval) |