path: root/rakelib/gcc.rake

# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at https://mozilla.org/MPL/2.0/. -}
# frozen_string_literal: true

require 'fileutils'
require 'uri'
require 'net/http'
require 'open3'
require 'pathname'

# Use Homebrew GCC if available (it uses libstdc++, avoiding
# macOS-specific libc++ incompatibilities in GCC's own sources).
class GCCConfiguration
  attr_reader :target

  def initialize(suffix, target, sysroot_sdk)
    @suffix = suffix
    @target = target
    @sysroot_sdk = sysroot_sdk
  end

  def cc
    "gcc#{@suffix}"
  end

  def cxx
    "g++#{@suffix}"
  end

  def configure
    @sysroot_sdk.nil? ? [] : ["--with-sysroot=#{@sysroot_sdk}"]
  end
end

def gcc_verbose(gcc_binary)
  read, write = IO.pipe
  sh({'LC_ALL' => 'C'}, gcc_binary, '--verbose', err: write)
  write.close
  output = read.read
  read.close
  output
end

def find_build_target(gcc_version)
  if RUBY_PLATFORM =~ /darwin/
    suffix = '-' + gcc_version.split('.').first
    mac_os_sdk = '/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk'
  else
    suffix = ''
  end
  build_target = gcc_verbose(ENV.fetch 'CC', "gcc#{suffix}")
    .lines
    .find { |line| line.start_with? 'Target: ' }
    .split(' ')
    .last
    .strip

  GCCConfiguration.new suffix, build_target, mac_os_sdk
end

def download_and_pipe(url, target, command)
  target.mkpath

  Net::HTTP.start(url.host, url.port, use_ssl: url.scheme == 'https') do |http|
    request = Net::HTTP::Get.new url.request_uri

    http.request request do |response|
      case response
      when Net::HTTPRedirection
        download_and_pipe URI.parse(response['location']), target, command
      when Net::HTTPSuccess
        Dir.chdir target.to_path do
          Open3.popen2(*command) do |stdin, stdout, wait_thread|
            Thread.new do
              stdout.each { |line| puts line }
            end

            response.read_body do |chunk|
              stdin.write chunk
            end
            stdin.close

            wait_thread.value
          end
        end
      else
        response.error!
      end
    end
  end
end

# Makes a link from the source tree in the GCC tree.
def link_frontend(source, destination)
  File.symlink Pathname.new(source).relative_path_from(destination), (destination + File.basename(source))
end

# Replaces an elna-native directive in the line with its dg-* equivalent,
# escaping the directive argument for dejagnu's Tcl evaluation.
def convert_directive(line, directive, dg_name)
  line.sub(/\(\*\s*#{Regexp.escape directive}\s+(.*?)\s*\*\)/) do
    escaped = Regexp.last_match(1).gsub(/[\\\[\]$"]/) { |character| "\\#{character}" }
    "(* { #{dg_name} \"#{escaped}\" } *)"
  end
end

def convert_test(source, target, category, extra_lines = [])
  File.open(target, 'wb') do |output|
    File.foreach(source) do |line|
      line = convert_directive(line, '@Error', 'dg-error')
      line = convert_directive(line, '@Flags', 'dg-additional-options')

      output.puts line
    end

    # Runnable tests compile, link and execute.
    output.puts '(* { dg-do run } *)' if category == 'runnable'

    extra_lines.each { |line| output.puts line }

    # Suppress excess output so stray diagnostics do not fail the test.
    output.puts '(* { dg-prune-output .* } *)'

    case category
    when 'compilable'
      # Assert that an output file was produced.
      output.puts '(* { dg-final { output-exists } } *)'
    when 'fail_compilation'
      # Assert that no output file was produced.
      output.puts '(* { dg-final { output-exists-not } } *)'
    end
  end
end

namespace :gcc do
  # Dependencies.
  GCC_VERSION = "16.1.0"
  HOST_GCC = 'build/host/gcc'
  HOST_INSTALL = Pathname.new 'build/host/install'
  GCC_TREE = Pathname.new "build/tools/gcc-#{GCC_VERSION}"
  GCC_PATCH = 'https://raw.githubusercontent.com/Homebrew/homebrew-core/refs/heads/main/Patches/gcc/gcc-16.1.0.diff'

  directory HOST_GCC
  directory HOST_INSTALL.to_path
  directory 'build/tools'

  desc 'Download the bootstrap compiler and its prerequisites'
  task download: 'build/tools' do
    url = URI.parse "https://gcc.gnu.org/pub/gcc/releases/gcc-#{GCC_VERSION}/gcc-#{GCC_VERSION}.tar.xz"

    download_and_pipe url, GCC_TREE.dirname, ['tar', '-Jxv']
    download_and_pipe URI.parse(GCC_PATCH), GCC_TREE, ['patch', '-p1']

    # GCC 16.1.0 registers 17 languages but CL_PARAMS is at bit 16,
    # which collides with the 17th language class (CL_Rust). Shift
    # every CL_* constant from bit 16 upward by one position.
    File.open(GCC_TREE + 'gcc/opts.h', 'r+') do |opts_h|
      content = opts_h.read.gsub(/\(1U << (\d+)\)/) do |m|
        "(1U << #{$1.to_i + 1})"
      end
      opts_h.seek 0, IO::SEEK_SET
      opts_h.write content
    end

    sh 'contrib/download_prerequisites', chdir: GCC_TREE.to_path
  end

  desc 'Link the frontend into the GCC source tree'
  task :link do
    source_destination = GCC_TREE + 'gcc/elna'
    test_destination = GCC_TREE + 'gcc/testsuite/elna.dg'

    rm_rf [source_destination, test_destination]
    mkdir_p [source_destination, test_destination]

    FileList['boot', 'include', 'COPYING3', 'README.md', 'gcc/gcc', 'gcc/*.in', 'gcc/lang*'].each do |file|
      link_frontend file, source_destination
    end
    FileList['gcc/dg.exp', 'README.md'].each do |file|
      link_frontend file, test_destination
    end
    destination = GCC_TREE + 'gcc/testsuite/lib'
    FileList['gcc/testlib/*'].each do |file|
      rm_f (destination + File.basename(file))
      link_frontend file, destination
    end
  end

  desc 'Configure the bootstrap compiler'
  task configure: [HOST_GCC, HOST_INSTALL.to_path] do |t|
    build_target = find_build_target GCC_VERSION
    configure_options = [
      "--prefix=#{File.realpath t.prerequisites.last}",
      '--enable-languages=c,c++,jit,elna',
      '--disable-bootstrap',
      '--disable-multilib',
      '--enable-host-shared',
      '--with-system-zlib',
      "--target=#{build_target.target}",
      "--build=#{build_target.target}",
      "--host=#{build_target.target}",
      *build_target.configure
    ]
    env = {
      'CC' => ENV['CC'] || build_target.cc,
      'CXX' => ENV['CXX'] || build_target.cxx
    }
    env['CFLAGS'] = env['CXXFLAGS'] = '-O0 -g -fPIC -I/opt/homebrew/opt/flex/include'

    configure = GCC_TREE.relative_path_from(HOST_GCC) + 'configure'
    sh env, configure.to_path, *configure_options, chdir: HOST_GCC
  end

  desc 'Make and install the bootstrap compiler'
  task :make do
    sh 'make', '-j', Etc.nprocessors.to_s, chdir: HOST_GCC
    sh 'make', 'install', chdir: HOST_GCC
  end

  desc 'Convert the testsuite into dejagnu format'
  task :convert do
    destination = GCC_TREE + 'gcc/testsuite/elna.dg'
    destination.mkpath
    source = Pathname.new 'testsuite'

    # Regenerate the category directories from scratch: this removes
    # converted tests whose sources are gone and adds new ones.
    %w[compilable fail_compilation runnable].each do |category|
      category_destination = destination + category
      category_source = source + category

      rm_rf category_destination
      mkdir_p category_destination

      category_source.each_child do |test_path|
        test_target = category_destination + test_path.basename

        # Multi-module tests: directories containing a sut.elna (system under
        # test) and any helper files, compiled and linked together.
        if test_path.directory?
          main = test_path + 'sut.elna'
          raise %(multi-module test directory \"#{test_path}\" must contain sut.elna) unless main

          test_target.mkdir
          modules = test_path.children - [main]

          modules.each do |extra|
            cp_r extra, test_target
          end
          extra_sources = test_target.glob("**/*.elna")
            .map { |extra| %("#{extra.relative_path_from test_target}") }

          convert_test main, (test_target + 'sut.elna'), category, [
            "(* { dg-additional-options \"-I#{test_target.expand_path}\" } *)",
            "(* { dg-additional-sources #{extra_sources * ' '} } *)"
          ]
        else
          convert_test test_path, test_target, category
        end
      end
    end
  end

  desc 'Run tests'
  task check: 'gcc:convert' do
    log_file = Pathname.new(HOST_GCC) + 'gcc/testsuite/elna/elna.log'

    sh 'make', 'check-elna', chdir: File.join(HOST_GCC, 'gcc')

    fail "\nSee #{log_file}." if log_file.file? and log_file.read =~ /^(FAIL|XPASS|UNRESOLVED|ERROR):/
  end

  desc 'Run clang-tidy'
  task :tidy do
    compile_db = Pathname.new 'compile_commands.json'

    raise "#{compile_db} is missing. Run: bear -- rake gcc:make" unless compile_db.exist?
    sources = FileList['boot/*.cc', 'gcc/gcc/*.cc', 'include/elna/**/*.h']
      .reject do |file|
        ['/elna1.', '/elna-spec.'].any? { |pattern| file.include? pattern }
      end
    build_target = find_build_target GCC_VERSION
    includes = ['.', build_target.target].collect do |inc|
      HOST_INSTALL + 'include/c++' + GCC_VERSION + inc
    end

    sh 'clang-tidy', '-p', compile_db.to_path, '--extra-arg=-w', '--warnings-as-errors=*',
      *includes.collect { |inc| "--extra-arg=-cxx-isystem#{inc.realpath}" },
      '--extra-arg=-stdlib=libstdc++', *sources
  end

  desc 'Build documentation'
  task :doc do
    sh 'make', 'html', chdir: File.join(HOST_GCC, 'gcc')
  end

  desc 'Run GCC linters and tests'
  task test: %w[gcc:tidy gcc:check]
end

desc 'Build the bootstrap compiler'
task gcc: %w[gcc:download gcc:link gcc:configure gcc:make]