Harmonize python shebang

[serge-sans-paille]

Summary

Before:

grep -r --include=\*.py -E '^#!' -h | sort | uniq -c

  1 #!/bin/env python
  6 #! /usr/bin/env python
162 #!/usr/bin/env python
  2 #! /usr/bin/env python3
 16 #!/usr/bin/env python3
  2 #! /usr/bin/python
 49 #!/usr/bin/python

After

grep -r --include=\*.py -E '^#!' -h | sort | uniq -c

220 #!/usr/bin/env python
 18 #!/usr/bin/env python3

I've kept python3 reference to capture the intent « this a py3 only script »

[arsenm]

Consistency is good

[lebedev.ri]

Sounds good to me too.
If this breaks some scripts previously used some different pattern, we'll, that would mean that the other scripts already using that pattern were broken already.

[compnerd]

Thanks for making these uniform.

clang/utils/clangdiag.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/clandiag.py

clang/utils/modfuzz.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 
 # To use:
 #  1) Update the 'decls' list below with your fuzzing configuration.
 #  2) Run with the clang binary as the command-line argument.
 
 from __future__ import absolute_import, division, print_function
 import random
 import subprocess

compiler-rt/lib/sanitizer_common/scripts/litlint_test.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 # Tests for litlint.py
 #
 # Usage: python litlint_test.py
 #
 # Returns nonzero if any test fails
 
 import litlint

compiler-rt/test/sanitizer_common/android_commands/android_compile.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import os, sys, subprocess
 from android_common import *
 
 
 here = os.path.abspath(os.path.dirname(sys.argv[0]))
 android_run = os.path.join(here, 'android_run.py')
 

compiler-rt/test/sanitizer_common/android_commands/android_run.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import os, signal, sys, subprocess, tempfile
 from android_common import *
 
 ANDROID_TMPDIR = '/data/local/tmp/Output'
 
 device_binary = host_to_device_path(sys.argv[0])
 

compiler-rt/test/sanitizer_common/ios_commands/iossim_compile.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import os, sys, subprocess
 
 output = None
 output_type = 'executable'
 
 args = sys.argv[1:]
 while args:

compiler-rt/test/sanitizer_common/ios_commands/iossim_env.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import os, sys, subprocess
 
 
 idx = 1
 for arg in sys.argv[1:]:
   if not "=" in arg:
     break
   idx += 1
   (argname, argval) = arg.split("=")
   os.environ["SIMCTL_CHILD_" + argname] = argval
 
 exitcode = subprocess.call(sys.argv[idx:])
 if exitcode > 125:
   exitcode = 126
 sys.exit(exitcode)

compiler-rt/test/sanitizer_common/ios_commands/iossim_prepare.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import json
 
 print(json.dumps({"env": {}}))

compiler-rt/test/sanitizer_common/ios_commands/iossim_run.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import glob, os, pipes, sys, subprocess
 
 
 device_id = os.environ.get('SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER')
 if not device_id:
   raise EnvironmentError("Specify SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER to select which simulator to use.")
 

debuginfo-tests/dexter/dexter.py

-#!/usr/bin/python
+#!/usr/bin/env python
 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """DExTer entry point. This is the only non-module file."""
 

debuginfo-tests/llgdb-tests/llgdb.py

-#!/bin/env python
+#!/usr/bin/env python
 """
 A gdb-compatible frontend for lldb that implements just enough
 commands to run the tests in the debuginfo-tests repository with lldb.
 """
 
 # ----------------------------------------------------------------------
 # Auto-detect lldb python module.
 import commands, platform, os,  sys

libc/AOR_v20.02/math/tools/plot.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 # ULP error plot tool.
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import numpy as np

libcxx/utils/google-benchmark/mingw.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 # encoding: utf-8
 
 import argparse
 import errno
 import logging
 import os
 import platform
 import re

lldb/examples/darwin/heap_find/heap.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # This module is designed to live inside the "lldb" python package
 # in the "lldb.macosx" package. To use this in the embedded python
 # interpreter using "lldb" just import it:
 #
 #   (lldb) script import lldb.macosx.heap
 #----------------------------------------------------------------------

lldb/examples/python/armv7_cortex_m_target_defintion.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #===-- armv7_cortex_m_target_definition.py.py ------------------*- C++ -*-===//
 #
 #                     The LLVM Compiler Infrastructure
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #

lldb/examples/python/bsd.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import cmd
 import optparse
 import os
 import shlex
 import struct
 import sys

lldb/examples/python/cmdtemplate.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 # ---------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py

lldb/examples/python/crashlog.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # To use this in the embedded python interpreter using "lldb":
 #
 #   cd /path/containing/crashlog.py
 #   lldb

lldb/examples/python/delta.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # This module will enable GDB remote packet logging when the
 # 'start_gdb_log' command is called with a filename to log to. When the
 # 'stop_gdb_log' command is called, it will disable the logging and
 # print out statistics about how long commands took to execute and also
 # will primnt ou
 # Be sure to add the python path that points to the LLDB shared library.

lldb/examples/python/disasm-stress-test.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import argparse
 import datetime
 import re
 import subprocess
 import sys
 import time
 

lldb/examples/python/disasm.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------

lldb/examples/python/file_extract.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 
 import string
 import struct
 import sys
 
 
 class FileExtract:
     '''Decode binary data from a file'''

lldb/examples/python/gdbremote.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # This module will enable GDB remote packet logging when the
 # 'start_gdb_log' command is called with a filename to log to. When the
 # 'stop_gdb_log' command is called, it will disable the logging and
 # print out statistics about how long commands took to execute and also
 # will primnt ou
 # Be sure to add the python path that points to the LLDB shared library.

lldb/examples/python/globals.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # For the shells csh, tcsh:
 #   ( setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ; ./globals.py <path> [<path> ...])
 #
 # For the shells sh, bash:
 #   PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ./globals.py <path> [<path> ...]
 #----------------------------------------------------------------------

lldb/examples/python/lldb_module_utils.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import lldb
 import optparse
 import shlex
 import string
 import sys
 

lldb/examples/python/lldbtk.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import lldb
 import shlex
 import sys
 try:
     from tkinter import *
     import tkinter.ttk as ttk

lldb/examples/python/mach_o.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import cmd
 import dict_utils
 import file_extract
 import optparse
 import re
 import struct

lldb/examples/python/memory.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py

lldb/examples/python/operating_system.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import lldb
 import struct
 
 
 class OperatingSystemPlugIn(object):
     """Class that provides data for an instance of a LLDB 'OperatingSystemPython' plug-in class"""
 

lldb/examples/python/performance.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------

lldb/examples/python/process_events.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------

lldb/examples/python/sbvalue.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import lldb
 
 
 class value(object):
     '''A class that wraps an lldb.SBValue object and returns an object that
     can be used as an object with attribytes:\n
     argv = a.value(lldb.frame.FindVariable('argv'))\n

lldb/examples/python/shadow.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import lldb
 import shlex
 
 
 @lldb.command("shadow")
 def check_shadow_command(debugger, command, exe_ctx, result, dict):

lldb/examples/python/sources.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 
 import lldb
 import shlex
 
 
 def dump_module_sources(module, result):
     if module:

lldb/examples/python/stacks.py

-#!/usr/bin/python
+#!/usr/bin/env python
 from __future__ import print_function
 import lldb
 import optparse
 import shlex
 
 
 def stack_frames(debugger, command, result, dict):
     command_args = shlex.split(command)

lldb/examples/python/symbolication.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # To use this in the embedded python interpreter using "lldb":
 #
 #   cd /path/containing/crashlog.py
 #   lldb

lldb/examples/python/types.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py

lldb/examples/python/x86_64_linux_target_definition.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #===-- x86_64_linux_target_definition.py -----------------------------*- C++ -*-===//
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 

lldb/examples/python/x86_64_qemu_target_definition.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #===-- x86_64_qemu_target_definition.py -----------------------------*- C++ -*-===//
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 

lldb/examples/python/x86_64_target_definition.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #===-- x86_64_target_definition.py -----------------------------*- C++ -*-===//
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 

lldb/scripts/analyze-project-deps.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 
 import argparse
 import itertools
 import os
 import re
 import sys
 from collections import defaultdict
 

lldb/scripts/reproducer-replay.py

-#! /usr/bin/env python3
+#!/usr/bin/env python3
 
 from multiprocessing import Pool
 import multiprocessing
 import argparse
 import tempfile
 import logging
 import os
 import subprocess

lldb/test/API/functionalities/plugins/python_os_plugin/operating_system.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import lldb
 import struct
 
 
 class OperatingSystemPlugIn(object):
     """Class that provides data for an instance of a LLDB 'OperatingSystemPython' plug-in class"""
 

lldb/test/API/functionalities/plugins/python_os_plugin/operating_system2.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import lldb
 import struct
 
 
 class OperatingSystemPlugIn(object):
     """Class that provides data for an instance of a LLDB 'OperatingSystemPython' plug-in class"""
 

lldb/test/API/functionalities/plugins/python_os_plugin/stepping_plugin_threads/operating_system.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import lldb
 import struct
 
 
 class OperatingSystemPlugIn(object):
     """Class that provides a OS plugin that along with the particular code in main.cpp
        emulates the following scenario:

lldb/test/Shell/helper/build.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 
 from __future__ import print_function
 
 import argparse
 import os
 import signal
 import subprocess
 import sys

lldb/third_party/Python/module/progress/progress.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 from __future__ import print_function
 
 import use_lldb_suite
 import six
 
 import sys
 import time

llvm/utils/DSAclean.py

-#! /usr/bin/python
+#!/usr/bin/env python
 
 #changelog: 
 #10/13/2005b: replaced the # in tmp(.#*)* with alphanumeric and _, this will then remove
 #nodes such as %tmp.1.i and %tmp._i.3
 #10/13/2005: exntended to remove variables of the form %tmp(.#)* rather than just 
 #%tmp.#, i.e. it now will remove %tmp.12.3.15 etc, additionally fixed a spelling error in
 #the comments
 #10/12/2005: now it only removes nodes and edges for which the label is %tmp.# rather

llvm/utils/DSAextract.py

-#! /usr/bin/python
+#!/usr/bin/env python
 
 #this is a script to extract given named nodes from a dot file, with
 #the associated edges.  An edge is kept iff for edge x -> y
 # x and y are both nodes specified to be kept.
 
 #known issues: if a line contains '->' and is not an edge line
 #problems will occur.  If node labels do not begin with
 #Node this also will not work.  Since this is designed to work

llvm/utils/benchmark/mingw.py

-#! /usr/bin/env python
+#!/usr/bin/env python
 # encoding: utf-8
 
 import argparse
 import errno
 import logging
 import os
 import platform
 import re

llvm/utils/docker/scripts/llvm_checksum/llvm_checksum.py

-#!/usr/bin/python
+#!/usr/bin/env python
 """ A small program to compute checksums of LLVM checkout.
 """
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
 import hashlib
 import logging

llvm/utils/lint/common_lint.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #
 # Common lint functions applicable to multiple types of files.
 
 from __future__ import print_function
 import re
 
 def VerifyLineLength(filename, lines, max_length):
   """Checks to make sure the file has no lines with lines exceeding the length

llvm/utils/lint/cpp_lint.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #
 # Checks C++ files to make sure they conform to LLVM standards, as specified in
 # http://llvm.org/docs/CodingStandards.html .
 #
 # TODO: add unittests for the verifier functions:
 # http://docs.python.org/library/unittest.html .
 
 from __future__ import print_function

llvm/utils/lint/generic_lint.py

-#!/usr/bin/python
+#!/usr/bin/env python
 #
 # Checks files to make sure they conform to LLVM standards which can be applied
 # to any programming language: at present, line length and trailing whitespace.
 
 import common_lint
 import sys
 
 class GenericCodeLint(common_lint.BaseLint):

llvm/utils/schedcover.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 # This creates a CSV file from the output of the debug output of subtarget:
 #   llvm-tblgen --gen-subtarget --debug-only=subtarget-emitter
 # With thanks to Dave Estes for mentioning the idea at 2014 LLVM Developers' Meeting
 
 import os;
 import sys;
 import re;

llvm/utils/testgen/mc-bundling-x86-gen.py

 
-#!/usr/bin/python
+#!/usr/bin/env python
 
 # Auto-generates an exhaustive and repetitive test for correct bundle-locked
 # alignment on x86.
 # For every possible offset in an aligned bundle, a bundle-locked group of every
 # size in the inclusive range [1, bundle_size] is inserted. An appropriate CHECK
 # is added to verify that NOP padding occurred (or did not occur) as expected.
 # Run with --align-to-end to generate a similar test with align_to_end for each
 # .bundle_lock directive.

openmp/runtime/tools/summarizeStats.py

-#!/usr/bin/python
+#!/usr/bin/env python
 
 import pandas as pd
 import numpy as np
 import re
 import sys
 import os
 import argparse
 import matplotlib

polly/test/update_check.py

-#! /usr/bin/env python3
+#!/usr/bin/env python3
 # -*- coding: UTF-8 -*-
 
 # Polly/LLVM update_check.py
 # Update lit FileCheck files by replacing the 'CHECK:' lines by the actual output of the 'RUN:' command.
 
 import argparse
 import os
 import subprocess

polly/utils/jscop2cloog.py

-#!/usr/bin/python
+#!/usr/bin/env python
 import argparse, os
 import json
 
 def getDomains(scop):
   statements = scop['statements'];
   numStatements = len(statements)
 
   output = "%s\n\n" % str(numStatements)

polly/utils/pyscop/jscop2iscc.py

-#!/usr/bin/python
+#!/usr/bin/env python
 import argparse, isl, os
 import json
 
 def printDomain(scop):
 
   domain = isl.USet('{}')
 
   for statement in scop['statements']: