Fix building and running under Qt 6.5.3;

.gitignore

@@ -13,6 +13,11 @@ DerivedData
 .mailmap
 results
 
+AAAAAAAA/
+build-dep-win/
+build-win/
+install-win/
+
 # Ignore Buildstream local files
 /Tools/buildstream/.bst2
 /Tools/buildstream/cache

Source/JavaScriptCore/CMakeLists.txt

@@ -1552,7 +1552,12 @@ endif ()
 if (CMAKE_COMPILER_IS_GNUCXX AND GCC_OFFLINEASM_SOURCE_MAP)
     message(STATUS "Enabling asm postprocessing")
 
-    set(LowLevelInterpreter_LAUNCHER "${RUBY_EXECUTABLE} ${JavaScriptCore_SCRIPTS_SOURCES_DIR}/postprocess-asm")
+    if (WIN32)
+        set(LowLevelInterpreter_LAUNCHER "${RUBY_EXECUTABLE} ${JavaScriptCore_SCRIPTS_SOURCES_DIR}/postprocess-asm-win")
+    else ()
+        set(LowLevelInterpreter_LAUNCHER "${RUBY_EXECUTABLE} ${JavaScriptCore_SCRIPTS_SOURCES_DIR}/postprocess-asm")
+    endif ()
+
     get_target_property(PROP_RULE_LAUNCH_COMPILE LowLevelInterpreterLib RULE_LAUNCH_COMPILE)
     if (PROP_RULE_LAUNCH_COMPILE)
         set(LowLevelInterpreter_LAUNCHER "${LowLevelInterpreter_LAUNCHER} ${PROP_RULE_LAUNCH_COMPILE}")

Source/JavaScriptCore/Scripts/postprocess-asm-win

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+
+# Copyright (C) 2020 Igalia S. L.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+# THE POSSIBILITY OF SUCH DAMAGE.
+
+# Wrapper for a .cpp -> .o compilation command. It
+# 1. converts the command to generate a `.s' file
+# 2. runs the ASM postprocessor on it to generate the final `.s` file
+# 3. assembles the `.s` file to a `.o` file
+
+$asm_suffix_pre = ".pre.s"
+$asm_suffix = ".s"
+$postprocessor = "#{File.dirname($0)}/resolve-asm-file-conflicts-win.rb"
+
+
+$intermediate_paths = []
+
+# We need to work with indices a lot and unfortunately 'getoptlong' in
+# the standard library doesn't expose optind, so we're going with
+# array searches for simplicity.
+def index_nofail(ary, f, errmsg)
+  idx = ary.index { |el|
+    f.call(el)
+  }
+  if idx.nil?
+    $stderr.puts(errmsg)
+    exit(3)
+  end
+  idx
+end
+
+# Find and return the source file for this compilation command,
+# removing it from the args. Note that the path (A) as it appears here
+# (coming from a cmake rule) is likely to be different to the
+# anonymous argument (B) to the compilation command. However, A will
+# be a suffix of B.
+#
+# Exit with an error if the argument is not there. This has already
+# been checked by `cxx-wrapper`, otherwise we wouldn't be running.
+def extract_input!(args)
+  prefix = '-DPOSTPROCESS_ASM='
+
+  idx = index_nofail(args, Proc.new { |arg|
+    arg.start_with?(prefix)
+  }, "No `-DPOSTPROCESS_ASM` argument`")
+
+  path = args[idx][prefix.size..-1]
+  if path.size == 0
+    $stderr.puts("Empty path in -DPOSTPROCESS_ASM=")
+    exit(3)
+  end
+  # We only need this to be defined for the preprocessor (not any
+  # wrapper) from now on.
+  args[idx] = "-DPOSTPROCESS_ASM"
+  path.gsub! '/', '\\\\'
+  return path
+end
+
+# Get the index of the first argument ending in this suffix.
+#
+# Exit with an error if the argument isn't there. We're only ever
+# called with arguments we know are being passed in by the build
+# system.
+def get_arg_idx_suffix(args, wanted)
+  index_nofail(args, Proc.new { |arg|
+                 arg.end_with?(wanted)
+               }, "No argument ends with #{wanted}")
+end
+
+# Get index of a given argument. Die if it's not there.
+def get_arg_idx(args, wanted)
+  index_nofail(args, Proc.new { |arg|
+                 arg == wanted
+               }, "No `#{wanted}` argument")
+end
+
+# Get the index of `-o` and verify that an argument follows.
+# Both are guaranteed to exist (from our build system).
+def get_o_idx(args)
+  i = get_arg_idx(args, '-o')
+  if (i + 1) >= args.size
+    $stderr.puts("No argument to `-o`")
+    exit(3)
+  end
+  i
+end
+
+# Run command and die if it fails, propagating the exit code.
+def run_cmd(cmd)
+  pid = Process.spawn(*cmd)
+  Process.waitpid(pid)
+  ret = $?
+  if not ret.success?
+    $stderr.puts("Error running cmd: #{ret}")
+    exit(ret.exitstatus)
+  end
+end
+
+# Convert
+#    cxx -o blah.o -c blah.cpp
+# to
+#    cxx -o blah.s -S blah.cpp
+def build_cxx_cmd(args)
+  c_idx = get_arg_idx(args, '-c')
+  o_idx = get_o_idx(args)
+
+  cxx_args = args.clone
+
+  cxx_args[c_idx] = '-S'
+  o_path = cxx_args[o_idx + 1]
+  cxx_args[o_idx + 1] = o_path.sub(/[.]obj$/, $asm_suffix)
+  $intermediate_paths << cxx_args[o_idx + 1]
+  if cxx_args[o_idx + 1] == o_path
+    $stderr.puts("Output file name not an object file: `#{o_path}`")
+    exit(3)
+  end
+  cxx_args
+end
+
+# Do
+#     mv blah.S blah.pre.S
+# The reason we do a rename instead of directly generating the .pre.s
+# file when compiling is so that the corresponding .dwo file will have
+# the correct name embedded.
+def rename_s_file(args)
+  o_path = args[get_o_idx(args) + 1]
+  File.rename(o_path.sub(/[.]obj$/, $asm_suffix),
+              o_path.sub(/[.]obj$/, $asm_suffix_pre))
+end
+
+# Build
+#     postprocessor blah.pre.S blah.S
+def build_postprocessor_cmd(args)
+  o_path = args[get_o_idx(args) + 1]
+
+  pp_args = [
+    "ruby",
+    $postprocessor,
+    o_path.sub(/[.]obj$/, $asm_suffix_pre), # input
+    o_path.sub(/[.]obj$/, $asm_suffix) # output
+  ]
+  $intermediate_paths << pp_args[-2]
+  $intermediate_paths << pp_args[-1]
+  pp_args
+end
+
+# Build
+#     cxx -o blah.o -c blah.S
+def build_as_cmd(args, i_path)
+  i_idx = get_arg_idx_suffix(args, i_path)
+  o_path = args[get_o_idx(args) + 1]
+
+  as_args = args.clone
+  i_path = as_args[i_idx]
+  as_args[i_idx] = o_path.sub(/[.]obj$/, $asm_suffix)
+  as_args
+end
+
+args = ARGV.to_a
+i_path = extract_input!(args)
+
+begin
+  run_cmd(build_cxx_cmd(args))
+  rename_s_file(args)
+  run_cmd(build_postprocessor_cmd(args))
+  run_cmd(build_as_cmd(args, i_path))
+ensure
+  $intermediate_paths.each { |p|
+    if File.exist?(p)
+      File.delete(p)
+    end
+  }
+end