[lldb] Enable TestFrameFormatNameWithArgs in case of cross compilation

[asahay]

Summary

TestFrameFormatNameWithArgs.test is enabled only in case of native
compilation but is applicable in case of cross compilation too. So,
provision support for enabling it in case of both, native and cross
compilation.

[Michael137]

lldb/test/Shell/helper/build.py

29

Why was this needed?

Other than that, LGTM

[asahay]

lldb/test/Shell/helper/build.py

29

IIUC, ~/lldb/test/Shell/helper/toolchain.py supplies LLDB's bitness (and not the target architecture) as arch to ~/lldb/test/Shell/helper/build.py unconditionally. However, we may require the target architecture too to customize the compile and link commands (we did in our downstream project, at least). Perhaps, we'd like both, LLDB's bitness and the target architecture to be supplied via separate options but I thought that lifting the restriction in question might've sufficed until we'd provisioned support for the same. Let me know if we'd like it handled (or, not dealt with at all) in this change itself, though, please.

[Michael137]

lldb/test/Shell/helper/build.py

29

Ah I see. So you're saying currently the build scripts conflate -m32/-m64 with the -march=<...> flags? Seems like a separate option for bitness vs. arch would be the way to go

This current patch could be split into a stack of 3:

1. Add -std flag
2. Switch the test case to use %build

and an independent patch

3. Handle the --arch confusion

[asahay]

Retain 'choices' for 'arch'.

lldb/test/Shell/Settings/TestFrameFormatNameWithArgs.test

 # UNSUPPORTED: system-windows
-# RUN: %clangxx_host -g -O0 %S/Inputs/names.cpp -std=c++17 -o %t.out
+# RUN: %build %S/Inputs/names.cpp --std c++17 -o %t.out
 # RUN: %lldb -b -s %s %t.out | FileCheck %s
 settings set -f frame-format "frame ${function.name-with-args}\n"
 break set -n foo
 break set -n operator<<
 break set -n returns_func_ptr
 run
 # CHECK: frame int ns::foo<int ()>(t={{.*}})
 c

lldb/test/Shell/helper/build.py

 
 
 parser = argparse.ArgumentParser(description='LLDB compilation wrapper')
 parser.add_argument('--arch',
                     metavar='arch',
                     dest='arch',
                     required=True,
                     default='host',
                     choices=['32', '64', 'host'],
                     help='Specify the architecture to target.')
 
 parser.add_argument('--compiler',
                     metavar='compiler',
                     dest='compiler',
                     required=True,
                     help='Path to a compiler executable, or one of the values [any, msvc, clang-cl, gcc, clang]')
 
parser.add_argument('-n', '--dry-run',
                     default=False,
                     help='Print the commands that would run, but dont actually run them')
 
 parser.add_argument('inputs',
                     metavar='file',
                     nargs='+',
                     help='Source file(s) to compile / object file(s) to link')
 
+parser.add_argument('--std',
+                    metavar='std',
+                    dest='std',
+                    required=False,
+                    help='Specify the C/C++ standard.')
+
 
 args = parser.parse_args(args=sys.argv[1:])
 
 
 def to_string(b):
     """Return the parameter as type 'str', possibly encoding it.
 
     In Python2, the 'str' type is the same as 'bytes'. In Python3, the
def __init__(self, toolchain_type, args, obj_ext):
         self.compiler = args.compiler
         self.clean = args.clean
         self.output = args.output
         self.mode = args.mode
         self.nodefaultlib = args.nodefaultlib
         self.verbose = args.verbose
         self.obj_ext = obj_ext
         self.lib_paths = args.libs_dir
+        self.std = args.std
 
     def _exe_file_name(self):
         assert self.mode != 'compile'
         return self.output
 
     def _output_name(self, input, extension, with_executable=False):
         basename = os.path.splitext(os.path.basename(input))[0] + extension
         if with_executable:
def _get_compilation_command(self, source, obj):
             args.append('-fms-compatibility-version=19')
         args.append('/c')
 
         args.append('/Fo' + obj)
         if self.toolchain_type == 'clang-cl':
             args.append('--')
         args.append(source)
 
+        if self.std:
+            args.append('/std:' + self.std)
+
         return ('compiling', [source], obj,
                 self.compile_env,
                 args)
 
     def _get_link_command(self):
         args = []
         args.append(self.linker)
         args.append('/DEBUG:FULL')
def _get_compilation_command(self, source, obj):
         args.append('-c')
 
         args.extend(['-o', obj])
         args.append(source)
 
         if sys.platform == 'darwin':
             args.extend(['-isysroot', self.apple_sdk])
 
+        if self.std:
+            args.append('-std={0}'.format(self.std))
+
         return ('compiling', [source], obj, None, args)
 
     def _get_link_command(self):
         args = []
         args.append(self.compiler)
         args.append('-m' + self.arch)
         if self.nodefaultlib:
             args.append('-nostdlib')
if args.verbose:
     print('  Output: ' + args.output)
     print('  Nodefaultlib: ' + str(args.nodefaultlib))
     print('  Opt: ' + args.opt)
     print('  Mode: ' + args.mode)
     print('  Clean: ' + str(args.clean))
     print('  Verbose: ' + str(args.verbose))
     print('  Dryrun: ' + str(args.dry))
     print('  Inputs: ' + format_text(args.inputs, 0, 10))
+    print('  C/C++ Standard: ' + str(args.std))
     print('Script Environment:')
     print_environment(os.environ)
 
 args.compiler = toolchain_path
 if not os.path.exists(args.compiler) and not args.dry:
     raise ValueError('The toolchain {} does not exist.'.format(args.compiler))
 
 if toolchain_type == 'msvc' or toolchain_type=='clang-cl':