metacc 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d74b463f2d62a82dbbe422b47e112052a25c95e8c51b957f01ec2545b2f8f227
-  data.tar.gz: 510bdbcba0c031de7909db0a989141afbecd9fa33bcf7b5066cf61d3dacc6f49
+  metadata.gz: bb94d9b47a11ec5a78ea57ae19417e6423287918287f675e43579af8015e4c63
+  data.tar.gz: b1237b3e41f2ae7ae68066441d742892ca77fd0427dc3e7b8f02b7f92049e535
 SHA512:
-  metadata.gz: bbfda6722b4f9fa4b59a6be206a1b5ca0503d77f5833dbe5ba07f46525b1f157e4ac5ca7853f0f18ae7efd4f9c2782993a0991e101fd102523323abfeea97dd1
-  data.tar.gz: 15f59e0d6f45de8501b38aa6429624dd759d7d7b126ce18c0def60bdd2d56648f4b116483753e2f93da60c3e205ec5fd00813844e59b4975d7e3c81c01cfd590
+  metadata.gz: 4774d4160c9939259634b2625b28a2975360c477c56c53ac689b4208defb698c4fbcbccf829f540583dfb94cf801fc62664e94cc900f52c64c28bfd6f763247c
+  data.tar.gz: dfd5493d3789ea3f18dbd1d7a6a15c345fe6eaeb262e022af7a79039bdd7b2707416312fc08e1ca86b333d91520dbb41457f6be5006d30157af934d4fe8b1497

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

@@ -17,13 +17,9 @@ module MetaCC
     }
 
     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 = {
@@ -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
 
@@ -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
@@ -214,19 +223,31 @@ module MetaCC
         raise OptionParser::InvalidOption, "must specify an output path (-o)"
       end
 
-      if run && (!link || flags.include?(:shared) || flags.include?(:static))
-        raise OptionParser::InvalidOption, "--run may not be used with -c, --shared, or --static"
+      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 !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
 

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[
+    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
-        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,
+      *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,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/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: [])
@@ -173,10 +202,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"],
@@ -191,6 +219,14 @@ module MetaCC
       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
@@ -204,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
@@ -281,17 +320,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-"],
       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"],
@@ -366,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)
@@ -375,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)
@@ -399,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
@@ -436,42 +488,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
@@ -480,4 +533,7 @@ module MetaCC
 
   end
 
+  class AutoToolchain
+  end
+
 end

data/lib/metacc/version.rb

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

metadata

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