metacc 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d74b463f2d62a82dbbe422b47e112052a25c95e8c51b957f01ec2545b2f8f227
-  data.tar.gz: 510bdbcba0c031de7909db0a989141afbecd9fa33bcf7b5066cf61d3dacc6f49
+  metadata.gz: d68166f1cf0263814b009c61e2b615ee36521656734bb4ef0b0e48677751fafa
+  data.tar.gz: 12133182cb6f8b899714eb7fdbc95868ecdbfd40fe80bbe43084ed79d0fa5e88
 SHA512:
-  metadata.gz: bbfda6722b4f9fa4b59a6be206a1b5ca0503d77f5833dbe5ba07f46525b1f157e4ac5ca7853f0f18ae7efd4f9c2782993a0991e101fd102523323abfeea97dd1
-  data.tar.gz: 15f59e0d6f45de8501b38aa6429624dd759d7d7b126ce18c0def60bdd2d56648f4b116483753e2f93da60c3e205ec5fd00813844e59b4975d7e3c81c01cfd590
+  metadata.gz: d3257e9318b06bfdc812d3a344dc3bece65e22199e4bbc68f3c5f9867593d8b1c4fa8e9376078abf0a056d75f6fa4a8782716152d50f24e6c0a314632f27d3d1
+  data.tar.gz: c413d78b53e7a7486a895e1595ec064173cca98235cd35ae595dcd31af9f95b4c526ce8c47b452b53955615ba0166e341a3b9e071508d457580479ca4397fb1f

data/bin/metacc

@@ -7,8 +7,7 @@ require "metacc/cli"
 
 begin
   MetaCC::CLI.new.run(ARGV)
-rescue MetaCC::CLI::InvalidOption,
-       MetaCC::ToolchainNotFoundError,
+rescue MetaCC::ToolchainNotFoundError,
        OptionParser::AmbiguousOption,
        OptionParser::MissingArgument,
        OptionParser::NeedlessArgument,

data/lib/metacc/cli.rb

@@ -12,32 +12,28 @@ module MetaCC
   class CLI
 
     WARNING_CONFIGS = {
-      "all" =>   :warn_all,
+      "all"   => :warn_all,
       "error" => :warn_error
     }
 
     SANITIZERS = {
-      "address" =>   :asan,
-      "addr" =>      :asan,
-      "undefined" => :ubsan,
-      "ub" =>        :ubsan,
-      "memory" =>    :msan,
-      "mem" =>       :msan,
-      "leak" =>      :lsan
+      nil      => :sanitize_default,
+      "memory" => :sanitize_memory,
+      "thread" => :sanitize_thread
     }
 
     TARGETS = {
       "sse4.2" => :sse4_2,
-      "avx" =>    :avx,
-      "avx2" =>   :avx2,
+      "avx"    => :avx,
+      "avx2"   => :avx2,
       "avx512" => :avx512,
       "native" => :native
     }.freeze
 
     STANDARDS = {
-      "c11" =>   :c11,
-      "c17" =>   :c17,
-      "c23" =>   :c23,
+      "c11"   => :c11,
+      "c17"   => :c17,
+      "c23"   => :c23,
       "c++11" => :cxx11,
       "c++14" => :cxx14,
       "c++17" => :cxx17,
@@ -48,11 +44,11 @@ module MetaCC
 
     # Maps --x<name> CLI option names to xflags toolchain-class keys.
     XFLAGS = {
-      "xmsvc" => MSVC,
-      "xgnu" => GNU,
-      "xclang" => Clang,
+      "xmsvc"    => MSVC,
+      "xgnu"     => GNU,
+      "xclang"   => Clang,
       "xclangcl" => ClangCL,
-      "xtinycc" => TinyCC
+      "xtinycc"  => TinyCC
     }.freeze
 
     def initialize(driver: Driver.new)
@@ -77,6 +73,7 @@ module MetaCC
         libs:          [],
         output_path:   nil,
         run:           false,
+        dry_run:       false,
         flags:         [],
         xflags:        {}
       }
@@ -106,12 +103,19 @@ module MetaCC
       parser.on("--std=STANDARD", "Specify the language standard") do |value|
         options[:flags] << STANDARDS[value]
       end
-      parser.on("-W OPTION", "Configure warnings") do |value|
+      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:"
@@ -119,7 +123,13 @@ module MetaCC
       parser.on("-g", "--debug-info", "Emit debugging symbols") do
         options[:flags] << :debug_info
       end
-      parser.on("-S", "--sanitize SANITIZER", "Enable sanitizer (address, undefined, leak, memory)") do |value|
+      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
 
@@ -132,10 +142,10 @@ module MetaCC
       parser.on("--lto", "Enable link time optimization") do
         options[:flags] << :lto
       end
-      parser.on("--omit-frame-pointer") do |value|
+      parser.on("--omit-frame-pointer") do
         options[:flags] << :omit_frame_pointer
       end
-      parser.on("--strict-aliasing") do |value|
+      parser.on("--strict-aliasing") do
         options[:flags] << :strict_aliasing
       end
 
@@ -145,13 +155,13 @@ module MetaCC
       parser.on("-m", "--arch=ARCH", "Target architecture") do |value|
         options[:flags] << TARGETS[value]
       end
-      parser.on("--pic", "Generate position independent code") do |value|
+      parser.on("--pic", "Generate position independent code") do
         options[:flags] << :pic
       end
-      parser.on("--no-rtti", "Disable runtime type information") do |value|
+      parser.on("--no-rtti", "Disable runtime type information") do
         options[:flags] << :no_rtti
       end
-      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do |value|
+      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do
         options[:flags] << :no_exceptions
       end
 
@@ -161,10 +171,10 @@ module MetaCC
       parser.on("--static", "Produce a static library") do
         options[:flags] << :static
       end
-      parser.on("--shared", "Produce a shared library") do |value|
+      parser.on("--shared", "Produce a shared library") do
         options[:flags] << :shared
       end
-      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do |value|
+      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do
         options[:flags] << :shared_compat
       end
       parser.on("-c", "Compile only (produce object files without linking)") do
@@ -176,7 +186,6 @@ module MetaCC
       parser.on("-L DIR", "Add linker library search path") do |value|
         options[:link_paths] << value
       end
-
       parser.on("-s", "--strip", "Strip unneeded symbols") do
         options[:flags] << :strip
       end
@@ -207,27 +216,44 @@ module MetaCC
 
     def validate_options!(flags, output_path, link:, run:)
       if !link && output_path
-        raise OptionParser::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 OptionParser::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 OptionParser::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
+      return unless options[:dry_run]
+
+      puts(result.map { |cmd| cmd.join(" ") })
     end
 
   end

data/lib/metacc/driver.rb

@@ -15,20 +15,29 @@ module MetaCC
   # available compiler found on the system (Clang, GCC, or MSVC).
   class Driver
 
-    RECOGNIZED_FLAGS = Set.new(
-      %i[
-        warn_all warn_error
-        c11 c17 c23
-        cxx11 cxx14 cxx17 cxx20 cxx23 cxx26
-        o0 o1 o2 o3 os lto
-        sse4_2 avx avx2 avx512 native
-        asan ubsan msan lsan
-        debug_info
-        omit_frame_pointer strict_aliasing
-        no_rtti no_exceptions
-        pic shared shared_compat static strip
-      ]
-    ).freeze
+    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([
+                          :warn_all,
+                          :warn_error,
+                          :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 +46,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
 
@@ -58,12 +67,13 @@ module MetaCC
     # @raise [CompileError] if the underlying toolchain executable returns a non-zero exit status
     def compile(
       input_files,
-      flags: [],
-      xflags: {},
+      flags:         [],
+      xflags:        {},
       include_paths: [],
-      defs: [],
-      env: {},
-      working_dir: "."
+      defs:          [],
+      env:           {},
+      working_dir:   ".",
+      dry_run:       false
     )
       flags = translate_flags(flags)
       flags.concat(xflags[@toolchain.class] || [])
@@ -75,6 +85,8 @@ module MetaCC
         defs:
       )
 
+      return [cmd] if dry_run
+
       !!run_command(cmd, env:, working_dir:)
     end
 
@@ -98,17 +110,18 @@ module MetaCC
     def compile_and_link(
       input_files,
       output_path,
-      flags: [],
-      xflags: {},
+      flags:         [],
+      xflags:        {},
       include_paths: [],
-      defs: [],
-      link_paths: [],
-      libs: [],
-      env: {},
-      working_dir: "."
+      defs:          [],
+      link_paths:    [],
+      libs:          [],
+      env:           {},
+      working_dir:   ".",
+      dry_run:       false
     )
-      output_type = if flags.include?(:shared)  then :shared
-                    elsif flags.include?(:static)  then :static
+      output_type = if flags.include?(:shared) then :shared
+                    elsif flags.include?(:static) then :static
                     else :executable
                     end
       output_path = apply_default_extension(output_path, output_type)
@@ -126,6 +139,8 @@ module MetaCC
         link_paths:
       )
 
+      return cmds if dry_run
+
       cmds.each { |cmd| run_command(cmd, env:, working_dir:) }
       output_path
     end
@@ -149,11 +164,21 @@ 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)
 

data/lib/metacc/platform.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module MetaCC
+
+  module Platform
+
+    def self.windows?
+      @windows ||= RbConfig::CONFIG["host_os"].match?(/mswin|mingw32|windows/)
+    end
+
+    def self.cygwin?
+      @cygwin ||= RbConfig::CONFIG["host_os"].match?(/cygwin/)
+    end
+
+    def self.apple?
+      @apple ||= RbConfig::CONFIG["host_os"].match?(/darwin/)
+    end
+
+    def self.executable_ext
+      if windows? || cygwin?
+        ".exe"
+      elsif apple?
+        ".dylib"
+      else
+        ""
+      end
+    end
+
+    def self.executable_ext
+      windows? || cygwin? ? ".exe" : ""
+    end
+
+    def self.shared_library_ext
+      if windows? || cygwin?
+        ".dll"
+      elsif apple?
+        ".dylib"
+      else
+        ".so"
+      end
+    end
+
+  end
+
+end

data/lib/metacc/toolchain.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "rbconfig"
+require "tempfile"
+require_relative "platform"
 
 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"
@@ -49,7 +78,7 @@ module MetaCC
     # The output mode (object files, shared library, static library, or
     # executable) is determined by the translated flags.
     def compile_command(
-      input_files,
+      _input_files,
       flags:,
       include_paths:,
       defs:
@@ -58,8 +87,8 @@ module MetaCC
     end
 
     def compile_and_link_commands(
-      input_files,
-      output_file,
+      _input_files,
+      _output_file,
       flags:,
       include_paths:,
       defs:,
@@ -76,20 +105,11 @@ module MetaCC
     # @param output_type [:objects, :shared, :static, :executable]
     # @return [String]
     def default_extension(output_type)
-      host_os = RbConfig::CONFIG["host_os"]
       case output_type
       when :objects    then ".o"
-      when :static     then ".a"
-      when :shared
-        if host_os.match?(/mswin|mingw|cygwin/)
-          ".dll"
-        elsif host_os.match?(/darwin/)
-          ".dylib"
-        else
-          ".so"
-        end
-      when :executable
-        host_os.match?(/mswin|mingw|cygwin/) ? ".exe" : ""
+      when :static     then ".a" # MingGW uses .a, not .lib
+      when :shared     then MetaCC::Platform.shared_library_ext
+      when :executable then MetaCC::Platform.executable_ext
       else
         raise ArgumentError, "unknown output_type: #{output_type.inspect}"
       end
@@ -114,7 +134,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: [])
@@ -149,6 +169,30 @@ module MetaCC
       [[c, *flags, *inc_flags, *def_flags, *input_files, *lib_path_flags, *lib_flags, "-o", output_file]]
     end
 
+    def self.platform_flags
+      if MetaCC::Platform.windows?
+        {
+          # MingGW doesn't have full UBsan support, but it can trap on detected errors.
+          # It does not support the address or leak sanitizers.
+          sanitize_default: ["-fsanitize=undefined", "-fsanitize-undefined-trap-on-error"],
+          # MingGW doesn't support the thread sanitizer
+          sanitize_thread: []
+        }
+      elsif MetaCC::Platform.apple?
+        # gcc's support for sanitizers on OSX/iOS is *very* spotty.
+        # So we disable everything.
+        {
+          sanitize_default: [],
+          sanitize_thread: []
+        }
+      else
+        # Otherwise assume Linux/BSD and keep the default
+        {}
+      end
+    end
+
+    private_class_method :platform_flags
+
     GNU_FLAGS = {
       o0:                    ["-O0"],
       o1:                    ["-O1"],
@@ -173,10 +217,9 @@ module MetaCC
       cxx20:                 ["-std=c++20"],
       cxx23:                 ["-std=c++23"],
       cxx26:                 ["-std=c++2c"],
-      asan:                  ["-fsanitize=address"],
-      ubsan:                 ["-fsanitize=undefined"],
-      msan:                  ["-fsanitize=memory"],
-      lsan:                  ["-fsanitize=leak"],
+      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"],
@@ -189,7 +232,15 @@ module MetaCC
       static:                ["-static"],
       strip:                 ["-Wl,--strip-unneeded"],
       debug:                 ["-D_GLIBCXX_DEBUG", "-fasynchronous-unwind-tables"]
-    }.freeze
+    }.merge(platform_flags).freeze
+
+  end
+
+  class GCC < GNU
+
+    def initialize(search_paths: [])
+      super("gcc", search_paths:)
+    end
 
     def flags
       GNU_FLAGS
@@ -204,7 +255,26 @@ module MetaCC
       super("clang", search_paths:)
     end
 
-    CLANG_FLAGS = GNU_FLAGS.merge(lto: ["-flto=thin"]).freeze
+    def self.platform_flags
+      if MetaCC::Platform.windows?
+        {
+          # The leak sanitizer is not supported on Windows
+          sanitize_default: ["-fsanitize=address,undefined"],
+          # The thread sanitizer is not supported on Windows
+          sanitize_thread:  []
+        }
+      else
+        # For all other platforms, stick with the defaults
+        {}
+      end
+    end
+
+    private_class_method :platform_flags
+
+    CLANG_FLAGS = GNU_FLAGS.merge(
+                    lto: ["-flto=thin"],
+                    sanitize_memory: ["-fsanitize=memory"] 
+                  ).merge(platform_flags)
 
     def flags
       CLANG_FLAGS
@@ -281,17 +351,16 @@ module MetaCC
       cxx20:                 ["/std:c++20"],
       cxx23:                 ["/std:c++23preview"],
       cxx26:                 ["/std:c++latest"],
-      asan:                  ["/fsanitize=address"],
-      ubsan:                 [],
-      msan:                  [],
-      lsan:                  [],
+      sanitize_default:      ["/fsanitize=address"],
+      sanitize_memory:       [],
+      sanitize_thread:       [],
       no_rtti:               ["/GR-"],
-      no_exceptions:         ["/EHs-", "/EHc-"],
+      no_exceptions:         ["/EHs-", "/EHc-", "/D_HAS_EXCEPTIONS=0"],
       pic:                   [],
       omit_frame_pointer:    ["/Oy"],
       no_omit_frame_pointer: ["/Oy-"],
-      strict_aliasing:       ["-fstrict-aliasing"],
-      no_strict_aliasing:    ["-fno-strict-aliasing"],
+      strict_aliasing:       [],
+      no_strict_aliasing:    [],
       shared:                ["/LD"],
       shared_compat:         ["/LD"],
       static:                ["/c"],
@@ -364,9 +433,9 @@ module MetaCC
     #
     # Parses the output of `vcvarsall.bat … && set` and merges the resulting
     # environment variables into the current process's ENV.
-    def MSVC.vcvarsall(devenv_path)
+    def self.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)
@@ -375,10 +444,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 %("#{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)
@@ -399,8 +479,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
@@ -418,7 +501,7 @@ module MetaCC
     end
 
     def compile_and_link_commands(input_files, output_file, **options)
-      commands = super(input_files, output_file, **options)
+      commands = super
       if options[:flags].include?(:static)
         object_files = input_files.map { |f| f.sub(/\.c\z/, ".o") }
         commands << [@ar, "rcs", output_file, *object_files]
@@ -436,42 +519,43 @@ module MetaCC
     end
 
     TINYCC_FLAGS = {
-      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:              [],
-      asan:               [],
-      ubsan:              [],
-      msan:               [],
-      leak:               [],
-      no_rtti:            [],
-      no_exceptions:      [],
-      pic:                [],
-      keep_frame_pointer: [],
-      relaxed_aliasing:   [],
-      shared:             ["-shared"],
-      shared_compat:      ["-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

data/lib/metacc/version.rb

@@ -2,6 +2,6 @@
 
 module MetaCC
 
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 
 end

data/lib/metacc.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
-require "metacc/driver"
 require "metacc/version"
+require "metacc/platform"
+require "metacc/toolchain"
+require "metacc/driver"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metacc
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Praneeth Sadda
@@ -22,6 +22,7 @@ files:
 - lib/metacc.rb
 - lib/metacc/cli.rb
 - lib/metacc/driver.rb
+- lib/metacc/platform.rb
 - lib/metacc/toolchain.rb
 - lib/metacc/version.rb
 homepage: https://github.com/psadda/metacc
@@ -38,7 +39,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="