metacc 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a14fc8ca9c502275a4cc8105906722c167fb58cf6a269559748da22cf88f83d3
-  data.tar.gz: f56a289ba4240caf683f8614f5317252753032ad8902cce314a0ab43380d05fd
+  metadata.gz: bb94d9b47a11ec5a78ea57ae19417e6423287918287f675e43579af8015e4c63
+  data.tar.gz: b1237b3e41f2ae7ae68066441d742892ca77fd0427dc3e7b8f02b7f92049e535
 SHA512:
-  metadata.gz: 2b5c6055a1445b3e0341fbde3da0ca9b76e2cfe021c0c7694be91233a2eb2c68de7f063cc5c2b9b953b697fdfa41f3a949b168eb33790d8544fedeeef90f222a
-  data.tar.gz: 30b826250c85ce5d7b57c83f81714d7ac51b6e911abed4ea8371e3bc36540f0b29779aeced94b398b7d590ffbbbf608c7ab2929f0d9743a8967824edad8bea59
+  metadata.gz: 4774d4160c9939259634b2625b28a2975360c477c56c53ac689b4208defb698c4fbcbccf829f540583dfb94cf801fc62664e94cc900f52c64c28bfd6f763247c
+  data.tar.gz: dfd5493d3789ea3f18dbd1d7a6a15c345fe6eaeb262e022af7a79039bdd7b2707416312fc08e1ca86b333d91520dbb41457f6be5006d30157af934d4fe8b1497

data/bin/metacc

@@ -7,7 +7,12 @@ require "metacc/cli"
 
 begin
   MetaCC::CLI.new.run(ARGV)
-rescue MetaCC::CLI::InvalidOption, MetaCC::ToolchainNotFoundError => e
+rescue MetaCC::ToolchainNotFoundError,
+       OptionParser::AmbiguousOption,
+       OptionParser::MissingArgument,
+       OptionParser::NeedlessArgument,
+       OptionParser::InvalidArgument,
+       OptionParser::InvalidOption => e
   warn "#{$0} error: #{e.message}"
 rescue MetaCC::CompileError => e
   warn e.message

data/lib/metacc/cli.rb

@@ -9,57 +9,19 @@ module MetaCC
   #
   # Usage:
   #   metacc <sources...> -o <output> [options]       – compile source file(s)
-  #
-  # General:
-  #   -Wall -Werror
-  #   --std=c11 --std=c17 --std=c23
-  #   --std=c++11 --std=c++14 --std=c++17 --std=c++20 --std=c++23 --std=c++26
-  #
-  # Linking:
-  #   -c                 – compile only; don't link
-  #   -l, -L             - specify linker input
-  #   --shared           – produce a shared library
-  #   --static           – produce a static library
-  #   --lto              - enable link time optimization
-  #   --strip / -s       – strip unneeded symbols
-  #
-  # Code generation:
-  #   -O0, -O1, -O2, -O3                             - Set the optimization level
-  #   -msse4.2 -mavx -mavx2 -mavx512 --arch=native   - Compile for the given target
-  #   --no-rtti --no-exceptions
-  #   --pic
-  #
-  # Debugging:
-  #   --debug / -g
-  #   --asan --ubsan --msan
-  #
-  # Toolchain-specific flags (passed to Driver#compile via xflags:):
-  #   --xmsvc VALUE     – appended to xflags[MSVC]
-  #   --xgnu  VALUE     – appended to xflags[GNU]
-  #   --xclang VALUE    – appended to xflags[Clang]
-  #   --xclangcl VALUE  – appended to xflags[ClangCL]
   class CLI
 
-    # Maps long-form CLI flag names to Driver::RECOGNIZED_FLAGS symbols.
-    # Optimization-level flags are handled separately via -O LEVEL.
-    LONG_FLAGS = {
-      "lto" =>                       :lto,
-      "asan" =>                      :asan,
-      "ubsan" =>                     :ubsan,
-      "msan" =>                      :msan,
-      "no-rtti" =>                   :no_rtti,
-      "no-exceptions" =>             :no_exceptions,
-      "pic" =>                       :pic,
-      "no-semantic-interposition" => :no_semantic_interposition,
-      "no-omit-frame-pointer" =>     :no_omit_frame_pointer,
-      "no-strict-aliasing" =>        :no_strict_aliasing
-    }.freeze
-
     WARNING_CONFIGS = {
       "all" =>   :warn_all,
       "error" => :warn_error
     }
 
+    SANITIZERS = {
+      nil =>      :sanitize_default,
+      "memory" => :sanitize_memory,
+      "thread" => :sanitize_thread,
+    }
+
     TARGETS = {
       "sse4.2" => :sse4_2,
       "avx" =>    :avx,
@@ -85,7 +47,8 @@ module MetaCC
       "xmsvc" => MSVC,
       "xgnu" => GNU,
       "xclang" => Clang,
-      "xclangcl" => ClangCL
+      "xclangcl" => ClangCL,
+      "xtinycc" => TinyCC
     }.freeze
 
     def initialize(driver: Driver.new)
@@ -110,6 +73,7 @@ module MetaCC
         libs:          [],
         output_path:   nil,
         run:           false,
+        dry_run:       false,
         flags:         [],
         xflags:        {}
       }
@@ -122,6 +86,11 @@ module MetaCC
     private
 
     def setup_compile_options(parser, options)
+      parser.require_exact = true
+
+      parser.separator ""
+      parser.separator "General options:"
+
       parser.on("-o FILEPATH", "Output file path") do |value|
         options[:output_path] = value
       end
@@ -131,26 +100,85 @@ module MetaCC
       parser.on("-D DEF", "Add a preprocessor definition") do |value|
         options[:defs] << value
       end
-      parser.on("-O LEVEL", /\A[0-3]|s\z/, "Optimization level (0–3)") do |level|
+      parser.on("--std=STANDARD", "Specify the language standard") do |value|
+        options[:flags] << STANDARDS[value]
+      end
+      parser.on(
+        "-W OPTION", "Configure warnings",
+        "  -Wall   => Enable a broad range of warnings",
+        "  -Werror => Treat warnings as errrs"
+      ) do |value|
+        options[:flags] << WARNING_CONFIGS[value]
+      end
+      parser.on("-r", "--run", "Run the compiled executable after a successful build") do
+        options[:run] = true
+      end
+      parser.on("--dry-run", "Print the command that would be issued") do
+        options[:dry_run] = true
+      end
+
+      parser.separator ""
+      parser.separator "Debugging:"
+
+      parser.on("-g", "--debug-info", "Emit debugging symbols") do
+        options[:flags] << :debug_info
+      end
+      parser.on(
+        "-S", "--sanitize=[SANITIZER]",
+        "Enable sanitizer(s)",
+        "  --sanitize        => address, undefined, leak",
+        "  --sanitize=memory => memory",
+        "  --sanitize=thread => thread",
+      ) do |value|
+        options[:flags] << SANITIZERS[value]
+      end
+
+      parser.separator ""
+      parser.separator "Optimization:"
+
+      parser.on("-O LEVEL", /\A[0-3]|s\z/, "Optimization level (0, 1, 2, 3, or s)") do |level|
         options[:flags] << :"o#{level}"
       end
-      parser.on("-m", "--arch ARCH", "Target architecture") do |value|
+      parser.on("--lto", "Enable link time optimization") do
+        options[:flags] << :lto
+      end
+      parser.on("--omit-frame-pointer") do |value|
+        options[:flags] << :omit_frame_pointer
+      end
+      parser.on("--strict-aliasing") do |value|
+        options[:flags] << :strict_aliasing
+      end
+
+      parser.separator ""
+      parser.separator "Code generation:"
+
+      parser.on("-m", "--arch=ARCH", "Target architecture") do |value|
         options[:flags] << TARGETS[value]
       end
-      parser.on("-g", "--debug", "Emit debugging symbols") do
-        options[:flags] << :debug
+      parser.on("--pic", "Generate position independent code") do |value|
+        options[:flags] << :pic
       end
-      parser.on("--std STANDARD", "Specify the language standard") do |value|
-        options[:flags] << STANDARDS[value]
+      parser.on("--no-rtti", "Disable runtime type information") do |value|
+        options[:flags] << :no_rtti
       end
-      parser.on("-W OPTION", "Configure warnings") do |value|
-        options[:flags] << WARNING_CONFIGS[value]
+      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do |value|
+        options[:flags] << :no_exceptions
       end
-      parser.on("-c", "Produce object files") do
-        options[:link] = false
+
+      parser.separator ""
+      parser.separator "Linking:"
+
+      parser.on("--static", "Produce a static library") do
+        options[:flags] << :static
       end
-      parser.on("-r", "--run", "Run the compiled executable after a successful build") do
-        options[:run] = true
+      parser.on("--shared", "Produce a shared library") do |value|
+        options[:flags] << :shared
+      end
+      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do |value|
+        options[:flags] << :shared_compat
+      end
+      parser.on("-c", "Compile only (produce object files without linking)") do
+        options[:link] = false
       end
       parser.on("-l LIB", "Link against library LIB") do |value|
         options[:libs] << value
@@ -158,59 +186,71 @@ module MetaCC
       parser.on("-L DIR", "Add linker library search path") do |value|
         options[:link_paths] << value
       end
-      parser.on("--shared", "Produce a shared library") do
-        options[:flags] << :shared
-      end
-      parser.on("--static", "Produce a static library") do
-        options[:flags] << :static
-      end
       parser.on("-s", "--strip", "Strip unneeded symbols") do
         options[:flags] << :strip
       end
-      LONG_FLAGS.each do |name, sym|
-        parser.on("--#{name}") do
-          options[:flags] << sym
-        end
-      end
-      XFLAGS.each do |name, tc_class|
-        parser.on("--#{name} VALUE", "Pass VALUE to the #{tc_class} toolchain") do |value|
-          options[:xflags][tc_class] ||= []
-          options[:xflags][tc_class] << value
+
+      parser.separator ""
+      parser.separator "Compiler specific:"
+
+      XFLAGS.each do |name, toolchain_class|
+        toolchain_name = toolchain_class.name.split("::").last
+        parser.on("--#{name} FLAG", "Forward FLAG to the compiler if compiling with #{toolchain_name}") do |value|
+          options[:xflags][toolchain_class] ||= []
+          options[:xflags][toolchain_class] << value
         end
       end
+
+      parser.separator ""
+      parser.separator "Informational:"
+
       parser.on_tail("--version", "Print the toolchain version and exit") do
         puts @driver.toolchain.version_banner
         exit
       end
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
     end
 
     def validate_options!(flags, output_path, link:, run:)
       if !link && output_path
-        raise InvalidOption, "cannot specify output path (-o) in compile only mode (-c)"
+        raise OptionParser::InvalidOption, "cannot specify output path (-o) in compile only mode (-c)"
       end
 
       if link && !output_path
-        raise InvalidOption, "must specify an output path (-o)"
+        raise OptionParser::InvalidOption, "must specify an output path (-o)"
+      end
+
+      if run && (!link || %i[static shared shared_compat].any? { |f| flags.include?(f) })
+        raise OptionParser::InvalidOption, "--run cannot be used with -c, --static, --shared, or --shared-compat"
       end
 
-      if run && (!link || flags.include?(:shared) || flags.include?(:static))
-        raise InvalidOption, "--run may not be used with -c, --shared, or --static"
+      if !link && %i[static shared shared_compat].any? { |f| flags.include?(f) }
+        raise OptionParser::InvalidOption, "compile only mode (-c) cannot be used with --static, --shared, or --shared-compat"
+      end
+
+      if flags.include?(:debug_info) && flags.include?(:strip)
+        raise OptionParser::InvalidOption, "--debug-info (-g) cannot be combined with --strip (-s)"
       end
     end
 
     def invoke(input_paths, desired_output_path = nil, link: true, run: false, **options)
+      result = nil
       if link
-        actual_output_path = @driver.compile_and_link(input_paths, desired_output_path, **options)
-        system(actual_output_path) if run
+        result = @driver.compile_and_link(input_paths, desired_output_path, **options)
+        system(result) if run && !options[:dry_run]
       else
         options.delete(:link_paths)
         options.delete(:libs)
-        @driver.compile(input_paths, **options)
+        result = @driver.compile(input_paths, **options)
+      end
+      if options[:dry_run]
+        puts result.map { |cmd| cmd.join(" ") }
       end
     end
 
-    class InvalidOption < StandardError; end
-
   end
 
 end

data/lib/metacc/driver.rb

@@ -15,20 +15,24 @@ module MetaCC
   # available compiler found on the system (Clang, GCC, or MSVC).
   class Driver
 
-    RECOGNIZED_FLAGS = Set.new(
-      %i[
-        o0 o1 o2 o3 os
-        sse4_2 avx avx2 avx512 native
-        debug lto
+    LANGUAGE_STD_FLAGS = Set.new(%i[c11 c17 c23 cxx11 cxx14 cxx17 cxx20 cxx23 cxx26]).freeze
+    ARCHITECTURE_FLAGS = Set.new(%i[sse4_2 avx avx2 avx512 native]).freeze
+    OPTIMIZATION_FLAGS = Set.new(%i[o0 o1 o2 o3 os]).freeze
+    DBG_SANITIZE_FLAGS = Set.new(%i[sanitize_default sanitize_memory sanitize_thread]).freeze
+
+    ALL_FLAGS = Set.new([
+      *%i[
         warn_all warn_error
-        c11 c17 c23
-        cxx11 cxx14 cxx17 cxx20 cxx23 cxx26
-        asan ubsan msan
-        no_rtti no_exceptions pic
-        no_semantic_interposition no_omit_frame_pointer no_strict_aliasing
-        shared static strip
-      ]
-    ).freeze
+        debug_info
+        omit_frame_pointer strict_aliasing
+        no_rtti no_exceptions
+        pic shared shared_compat static strip
+      ],
+      *LANGUAGE_STD_FLAGS,
+      *ARCHITECTURE_FLAGS,
+      *OPTIMIZATION_FLAGS,
+      *DBG_SANITIZE_FLAGS
+    ]).freeze
 
     # The detected toolchain (a Toolchain subclass instance).
     attr_reader :toolchain
@@ -37,11 +41,11 @@ module MetaCC
     #
     # @param prefer       [Array<Class>] toolchain classes to probe, in priority order.
     #                                   Each element must be a Class derived from Toolchain.
-    #                                   Defaults to [Clang, GNU, MSVC].
+    #                                   Defaults to [Clang, GCC, MSVC].
     # @param search_paths [Array<String>] directories to search for toolchain executables
     #                                    before falling back to PATH. Defaults to [].
     # @raise [ToolchainNotFoundError] if no supported compiler is found.
-    def initialize(prefer: [MSVC], search_paths: [])
+    def initialize(prefer: [Clang, GCC, MSVC], search_paths: [])
       @toolchain = select_toolchain!(prefer, search_paths)
     end
 
@@ -63,7 +67,8 @@ module MetaCC
       include_paths: [],
       defs: [],
       env: {},
-      working_dir: "."
+      working_dir: ".",
+      dry_run: false
     )
       flags = translate_flags(flags)
       flags.concat(xflags[@toolchain.class] || [])
@@ -75,6 +80,8 @@ module MetaCC
         defs:
       )
 
+      return [cmd] if dry_run
+
       !!run_command(cmd, env:, working_dir:)
     end
 
@@ -105,7 +112,8 @@ module MetaCC
       link_paths: [],
       libs: [],
       env: {},
-      working_dir: "."
+      working_dir: ".",
+      dry_run: false
     )
       output_type = if flags.include?(:shared)  then :shared
                     elsif flags.include?(:static)  then :static
@@ -126,6 +134,8 @@ module MetaCC
         link_paths:
       )
 
+      return cmds if dry_run
+
       cmds.each { |cmd| run_command(cmd, env:, working_dir:) }
       output_path
     end
@@ -149,11 +159,24 @@ module MetaCC
     end
 
     def translate_flags(flags)
-      unrecognized_flag = flags.find { |flag| !RECOGNIZED_FLAGS.include?(flag) }
+      unrecognized_flag = flags.find { |flag| !ALL_FLAGS.include?(flag) }
       if unrecognized_flag
         raise "#{unrecognized_flag.inspect} is not a known flag"
       end
 
+      lang_flags, flags = flags.partition { |flag| LANGUAGE_STD_FLAGS.include?(flag) }
+      arch_flags, flags = flags.partition { |flag| ARCHITECTURE_FLAGS.include?(flag) }
+      optm_flags, flags = flags.partition { |flag| OPTIMIZATION_FLAGS.include?(flag) }
+      sant_flags, flags = flags.partition { |flag| DBG_SANITIZE_FLAGS.include?(flag) }
+
+      flags << lang_flags.last unless lang_flags.empty?
+      flags << arch_flags.last unless arch_flags.empty?
+      flags << optm_flags.last unless optm_flags.empty?
+      flags << sant_flags.last unless sant_flags.empty?
+
+      flags << :no_omit_frame_pointer unless flags.include?(:omit_frame_pointer)
+      flags << :no_strict_aliasing unless flags.include?(:strict_aliasing)
+
       flags.flat_map { |flag| @toolchain.flags[flag] }
     end
 

data/lib/metacc/toolchain.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbconfig"
+require "tempfile"
 
 module MetaCC
 
@@ -40,6 +41,34 @@ module MetaCC
       IO.popen([c, "--version", { err: :out }], &:read)
     end
 
+    # Parses +banner_text+ (e.g. from +version_banner+) and returns the
+    # Toolchain subclass it most likely belongs to, or +nil+ if unrecognised.
+    #
+    # Detection is order-sensitive: ClangCL must be checked before Clang
+    # because both banners contain "clang", but only ClangCL's Target line
+    # contains "windows-msvc".
+    def self.detect_from_version_banner(banner_text)
+      case banner_text
+      when /windows-msvc/i then ClangCL
+      when /clang/i        then Clang
+      when /\bgcc\b/i      then GCC
+      when /microsoft/i    then MSVC
+      when /\btcc\b/i      then TinyCC
+      end
+    end
+
+    def self.from_command(command)
+      toolchain_class = nil
+      %w[--version -v].each do |flag|
+        banner = IO.popen([command, flag, { err: :out }], &:read)
+        toolchain_class = detect_from_version_banner(banner)
+        break if toolchain_class
+      rescue Errno::ENOENT
+        # Do nothing
+      end
+      toolchain_class&.new
+    end
+
     # Returns a Hash mapping universal flags to native flags for this toolchain.
     def flags
       raise "#{self.class}#flags not implemented"
@@ -114,7 +143,7 @@ module MetaCC
 
   end
 
-  # GNU-compatible toolchain (gcc).
+  # Base class for GNU compatible (ish) toolchains
   class GNU < Toolchain
 
     def initialize(cc_command = "gcc", search_paths: [])
@@ -150,43 +179,54 @@ module MetaCC
     end
 
     GNU_FLAGS = {
-      o0:                        ["-O0"],
-      o1:                        ["-O1"],
-      o2:                        ["-O2"],
-      o3:                        ["-O3"],
-      os:                        ["-Os"],
-      sse4_2:                    ["-march=x86-64-v2"], # This is a better match for /arch:SSE4.2 than -msse4_2 is
-      avx:                       ["-march=x86-64-v2", "-mavx"],
-      avx2:                      ["-march=x86-64-v3"], # This is a better match for /arch:AVX2 than -mavx2 is
-      avx512:                    ["-march=x86-64-v4"],
-      native:                    ["-march=native", "-mtune=native"],
-      debug:                     ["-g3"],
-      lto:                       ["-flto"],
-      warn_all:                  ["-Wall", "-Wextra", "-pedantic"],
-      warn_error:                ["-Werror"],
-      c11:                       ["-std=c11"],
-      c17:                       ["-std=c17"],
-      c23:                       ["-std=c23"],
-      cxx11:                     ["-std=c++11"],
-      cxx14:                     ["-std=c++14"],
-      cxx17:                     ["-std=c++17"],
-      cxx20:                     ["-std=c++20"],
-      cxx23:                     ["-std=c++23"],
-      cxx26:                     ["-std=c++2c"],
-      asan:                      ["-fsanitize=address"],
-      ubsan:                     ["-fsanitize=undefined"],
-      msan:                      ["-fsanitize=memory"],
-      no_rtti:                   ["-fno-rtti"],
-      no_exceptions:             ["-fno-exceptions", "-fno-unwind-tables"],
-      pic:                       ["-fPIC"],
-      no_semantic_interposition: ["-fno-semantic-interposition"],
-      no_omit_frame_pointer:     ["-fno-omit-frame-pointer"],
-      no_strict_aliasing:        ["-fno-strict-aliasing"],
-      shared:                    ["-shared"],
-      static:                    ["-static"],
-      strip:                     ["-Wl,--strip-unneeded"]
+      o0:                    ["-O0"],
+      o1:                    ["-O1"],
+      o2:                    ["-O2"],
+      o3:                    ["-O3"],
+      os:                    ["-Os"],
+      sse4_2:                ["-march=x86-64-v2"], # This is a better match for /arch:SSE4.2 than -msse4_2 is
+      avx:                   ["-march=x86-64-v2", "-mavx"],
+      avx2:                  ["-march=x86-64-v3"], # This is a better match for /arch:AVX2 than -mavx2 is
+      avx512:                ["-march=x86-64-v4"],
+      native:                ["-march=native", "-mtune=native"],
+      debug_info:            ["-g3"],
+      lto:                   ["-flto"],
+      warn_all:              ["-Wall", "-Wextra", "-pedantic"],
+      warn_error:            ["-Werror"],
+      c11:                   ["-std=c11"],
+      c17:                   ["-std=c17"],
+      c23:                   ["-std=c23"],
+      cxx11:                 ["-std=c++11"],
+      cxx14:                 ["-std=c++14"],
+      cxx17:                 ["-std=c++17"],
+      cxx20:                 ["-std=c++20"],
+      cxx23:                 ["-std=c++23"],
+      cxx26:                 ["-std=c++2c"],
+      sanitize_default:      ["-fsanitize=address,undefined,leak"],
+      sanitize_memory:       [],
+      sanitize_thread:       ["-fsanitize=thread"],
+      no_rtti:               ["-fno-rtti"],
+      no_exceptions:         ["-fno-exceptions", "-fno-unwind-tables"],
+      pic:                   ["-fPIC"],
+      omit_frame_pointer:    ["-fomit-frame-pointer"],
+      no_omit_frame_pointer: ["-fno-omit-frame-pointer"],
+      strict_aliasing:       ["-fstrict-aliasing"],
+      no_strict_aliasing:    ["-fno-strict-aliasing"],
+      shared:                ["-shared", "-Bsymbolic-non-weak-functions", "-fno-semantic-interposition"],
+      shared_compat:         ["-shared"],
+      static:                ["-static"],
+      strip:                 ["-Wl,--strip-unneeded"],
+      debug:                 ["-D_GLIBCXX_DEBUG", "-fasynchronous-unwind-tables"]
     }.freeze
 
+  end
+
+  class GCC < GNU
+
+    def initialize(search_paths: [])
+      super("gcc", search_paths:)
+    end
+
     def flags
       GNU_FLAGS
     end
@@ -200,7 +240,10 @@ module MetaCC
       super("clang", search_paths:)
     end
 
-    CLANG_FLAGS = GNU_FLAGS.merge(lto: ["-flto=thin"]).freeze
+    CLANG_FLAGS = GNU_FLAGS.merge(
+      lto: ["-flto=thin"],
+      sanitize_memory: ["-fsanitize=memory"]
+    ).freeze
 
     def flags
       CLANG_FLAGS
@@ -254,41 +297,43 @@ module MetaCC
     end
 
     MSVC_FLAGS = {
-      o0:                        ["/Od"],
-      o1:                        ["/O1"],
-      o2:                        ["/O2"],
-      o3:                        ["/O2", "/Ob3"],
-      os:                        ["/O1"],
-      sse4_2:                    ["/arch:SSE4.2"],
-      avx:                       ["/arch:AVX"],
-      avx2:                      ["/arch:AVX2"],
-      avx512:                    ["/arch:AVX512"],
-      native:                    [],
-      debug:                     ["/Zi"],
-      lto:                       ["/GL"],
-      warn_all:                  ["/W4"],
-      warn_error:                ["/WX"],
-      c11:                       ["/std:c11"],
-      c17:                       ["/std:c17"],
-      c23:                       ["/std:clatest"],
-      cxx11:                     [],
-      cxx14:                     ["/std:c++14"],
-      cxx17:                     ["/std:c++17"],
-      cxx20:                     ["/std:c++20"],
-      cxx23:                     ["/std:c++23preview"],
-      cxx26:                     ["/std:c++latest"],
-      asan:                      ["/fsanitize=address"],
-      ubsan:                     [],
-      msan:                      [],
-      no_rtti:                   ["/GR-"],
-      no_exceptions:             ["/EHs-", "/EHc-"],
-      pic:                       [],
-      no_semantic_interposition: [],
-      no_omit_frame_pointer:     ["/Oy-"],
-      no_strict_aliasing:        [],
-      shared:                    ["/LD"],
-      static:                    ["/c"],
-      strip:                     []
+      o0:                    ["/Od"],
+      o1:                    ["/O1"],
+      o2:                    ["/O2"],
+      o3:                    ["/O2", "/Ob3"],
+      os:                    ["/O1"],
+      sse4_2:                ["/arch:SSE4.2"],
+      avx:                   ["/arch:AVX"],
+      avx2:                  ["/arch:AVX2"],
+      avx512:                ["/arch:AVX512"],
+      native:                [],
+      debug_info:            ["/Zi"],
+      lto:                   ["/GL"],
+      warn_all:              ["/W4"],
+      warn_error:            ["/WX"],
+      c11:                   ["/std:c11"],
+      c17:                   ["/std:c17"],
+      c23:                   ["/std:clatest"],
+      cxx11:                 [],
+      cxx14:                 ["/std:c++14"],
+      cxx17:                 ["/std:c++17"],
+      cxx20:                 ["/std:c++20"],
+      cxx23:                 ["/std:c++23preview"],
+      cxx26:                 ["/std:c++latest"],
+      sanitize_default:      ["/fsanitize=address"],
+      sanitize_memory:       [],
+      sanitize_thread:       [],
+      no_rtti:               ["/GR-"],
+      no_exceptions:         ["/EHs-", "/EHc-"],
+      pic:                   [],
+      omit_frame_pointer:    ["/Oy"],
+      no_omit_frame_pointer: ["/Oy-"],
+      strict_aliasing:       [],
+      no_strict_aliasing:    [],
+      shared:                ["/LD"],
+      shared_compat:         ["/LD"],
+      static:                ["/c"],
+      strip:                 []
     }.freeze
 
     def flags
@@ -359,7 +404,7 @@ module MetaCC
     # environment variables into the current process's ENV.
     def MSVC.vcvarsall(devenv_path)
       # See https://stackoverflow.com/a/19929778
-      return if ENV.has_key?("DevEnvDir")
+      return if ENV.key?("DevEnvDir")
 
       # Calculate the location of vcvarsall.bat
       install_root = File.expand_path("../../..", devenv_path)
@@ -368,10 +413,21 @@ module MetaCC
       vcvarsall = File.join(install_root, "VC", "Auxiliary", "Build", "vcvarsall.bat")
       return unless File.exist?(vcvarsall)
 
-      # Run vcvarsall.bat and dump the environment to the shell
-      output = `"#{vcvarsall}" x64 && set`
-      status = $?
-      return unless status.success?
+      # Get environment info from vcvarsall.bat
+      output = nil
+      Tempfile.create(["vcvarsall", ".bat"]) do |file|
+        # Write a stub batch file that run vcvarsall.bat and dumps the
+        # environment to stdout
+        file.puts %Q{"#{vcvarsall.gsub('"', '""')}" x64 && set}
+        file.flush
+
+        # Run the stub batch file
+        output = IO.popen(["cmd", "/c", file.path], &:read)
+        status = $?
+        return unless status.success?
+      rescue Errno::ENOENT
+        return
+      end
 
       output.each_line do |line|
         key, value = line.chomp.split("=", 2)
@@ -392,8 +448,11 @@ module MetaCC
     end
 
     CLANG_CL_FLAGS = MSVC_FLAGS.merge(
-      o3:  ["/Ot"],       # Clang-CL treats /Ot as -O3
-      lto: ["-flto=thin"]
+      lto:                ["-flto=thin"],
+      o3:                 ["/Ot"],       # Clang-CL treats /Ot as -O3
+      native:             ["/clang:-march=native", "/clang:-mtune=native"],
+      strict_aliasing:    ["/clang:-fstrict-aliasing"],
+      no_strict_aliasing: ["/clang:-fno-strict-aliasing"]
     ).freeze
 
     def flags
@@ -416,6 +475,7 @@ module MetaCC
         object_files = input_files.map { |f| f.sub(/\.c\z/, ".o") }
         commands << [@ar, "rcs", output_file, *object_files]
       end
+      commands
     end
 
     # TinyCC does not support C++.
@@ -428,41 +488,43 @@ module MetaCC
     end
 
     TINYCC_FLAGS = {
-      o0:                        [],
-      o1:                        ["-O1"],
-      o2:                        ["-O2"],
-      o3:                        ["-O2"],
-      os:                        [],
-      sse4_2:                    [],
-      avx:                       [],
-      avx2:                      [],
-      avx512:                    [],
-      native:                    [],
-      debug:                     ["-g"],
-      lto:                       [],
-      warn_all:                  ["-Wall"],
-      warn_error:                ["-Werror"],
-      c11:                       [],
-      c17:                       [],
-      c23:                       [],
-      cxx11:                     [],
-      cxx14:                     [],
-      cxx17:                     [],
-      cxx20:                     [],
-      cxx23:                     [],
-      cxx26:                     [],
-      asan:                      [],
-      ubsan:                     [],
-      msan:                      [],
-      no_rtti:                   [],
-      no_exceptions:             [],
-      pic:                       [],
-      no_semantic_interposition: [],
-      no_omit_frame_pointer:     [],
-      no_strict_aliasing:        [],
-      shared:                    ["-shared"],
-      static:                    ["-c"],
-      strip:                     []
+      o0:                    [],
+      o1:                    ["-O1"],
+      o2:                    ["-O2"],
+      o3:                    ["-O2"],
+      os:                    [],
+      sse4_2:                [],
+      avx:                   [],
+      avx2:                  [],
+      avx512:                [],
+      native:                [],
+      debug_info:            ["-g"],
+      lto:                   [],
+      warn_all:              ["-Wall"],
+      warn_error:            ["-Werror"],
+      c11:                   [],
+      c17:                   [],
+      c23:                   [],
+      cxx11:                 [],
+      cxx14:                 [],
+      cxx17:                 [],
+      cxx20:                 [],
+      cxx23:                 [],
+      cxx26:                 [],
+      sanitize_default:      [],
+      sanitize_memory:       [],
+      sanitize_thread:       [],
+      no_rtti:               [],
+      no_exceptions:         [],
+      pic:                   [],
+      omit_frame_pointer:    [],
+      no_omit_frame_pointer: [],
+      strict_aliasing:       [],
+      no_strict_aliasing:    [],
+      shared:                ["-shared"],
+      shared_compat:         ["-shared"],
+      static:                ["-c"],
+      strip:                 []
     }.freeze
 
     def flags
@@ -471,4 +533,7 @@ module MetaCC
 
   end
 
+  class AutoToolchain
+  end
+
 end

data/lib/metacc/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module MetaCC
 
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metacc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Praneeth Sadda