# Copyright 2016 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# The yasm build process creates a slew of small C subprograms that
# dynamically generate files at various point in the build process.  This makes
# the build integration moderately complex.
#
# There are three classes of dynamically generated files:
#   1) C source files that should be included in the build (eg., lc3bid.c)
#   2) C source files that are #included by static C sources (eg., license.c)
#   3) Intermediate files that are used as input by other subprograms to
#      further generate files in category #1 or #2.  (eg., version.mac)
#
# This structure is represented with the following targets:
#   1) yasm -- Sources, flags for the main yasm executable. Also has most of
#              of the actions and rules that invoke the subprograms.
#   2) yasm_config -- General build configuration including setting a
#              inputs listing the checked in version of files
#              generated by manually running configure. These manually
#              generated files are used by all binaries.
#   3) yasm_utils -- Object files with memory management and hashing utilities
#              shared between yasm and the genperf subprogram.
#   4) genmacro, genmodule, etc. -- One executable target for each subprogram.
#   5) generate_license, generate_module, etc. -- Actions that invoke programs
#              built in #4 to generate .c files.
#   6) compile_gperf, compile_re2c, etc. -- Actions that invoke programs that
#              turn intermediate files into .c files.

if (current_toolchain == host_toolchain) {
  # Various files referenced by multiple targets.
  yasm_gen_include_dir = "$target_gen_dir/include"
  config_makefile = "config/$host_os/Makefile"
  version_file = "version.mac"

  import("//build/compiled_action.gni")

  config("yasm_config") {
    include_dirs = [
      "config/$host_os",
      ".",
    ]
    defines = [ "HAVE_CONFIG_H" ]
    cflags = [ "-std=gnu99" ]
  }

  executable("genmacro") {
    sources = [
      "tools/genmacro/genmacro.c",
    ]
    configs += [ ":yasm_config" ]
  }

  executable("genmodule") {
    sources = [
      "libyasm/genmodule.c",
    ]
    configs += [ ":yasm_config" ]
  }

  executable("genperf") {
    sources = [
      "tools/genperf/genperf.c",
      "tools/genperf/perfect.c",
    ]

    configs += [ ":yasm_config" ]

    deps = [
      ":yasm_utils",
    ]
  }

  # Used by both yasm and genperf binaries.
  static_library("yasm_utils") {
    sources = [
      "libyasm/phash.c",
      "libyasm/xmalloc.c",
      "libyasm/xstrdup.c",
    ]

    configs += [ ":yasm_config" ]
  }

  executable("genstring") {
    sources = [
      "genstring.c",
    ]
    configs += [ ":yasm_config" ]
  }

  executable("genversion") {
    sources = [
      "modules/preprocs/nasm/genversion.c",
    ]
    configs += [ ":yasm_config" ]
  }

  config("re2c_warnings") {
    # re2c is missing CLOSEVOP from one switch.
    if (is_clang) {
      cflags = [
        # re2c is missing CLOSEVOP from one switch.
        "-Wno-switch",

        # re2c contains many static functions in headers (because it's
        # a C library predating C99.)
        "-Wno-unused-function",

        # re2 may have questionable indentation. We should come back later
        # to confirm if this indentation is expected.
        "-Wno-misleading-indentation",
      ]
    }
  }

  executable("re2c") {
    sources = [
      "tools/re2c/actions.c",
      "tools/re2c/code.c",
      "tools/re2c/dfa.c",
      "tools/re2c/main.c",
      "tools/re2c/mbo_getopt.c",
      "tools/re2c/parser.c",
      "tools/re2c/scanner.c",
      "tools/re2c/substr.c",
      "tools/re2c/translate.c",
    ]

    configs += [
      ":yasm_config",
      ":re2c_warnings",
    ]
  }

  config("yasm_warnings") {
    if (is_clang) {
      cflags = [
        # reg3264type in x86expr.c is unused.
        "-Wno-unused-local-typedef",
        "-Wno-null-pointer-arithmetic",
      ]
    }
  }

  executable("yasm") {
    sources = [
      "frontends/yasm/yasm-options.c",
      "frontends/yasm/yasm.c",
      "libyasm/assocdat.c",
      "libyasm/bc-align.c",
      "libyasm/bc-data.c",
      "libyasm/bc-incbin.c",
      "libyasm/bc-org.c",
      "libyasm/bc-reserve.c",
      "libyasm/bitvect.c",
      "libyasm/bytecode.c",
      "libyasm/errwarn.c",
      "libyasm/expr.c",
      "libyasm/file.c",
      "libyasm/floatnum.c",
      "libyasm/hamt.c",
      "libyasm/insn.c",
      "libyasm/intnum.c",
      "libyasm/inttree.c",
      "libyasm/linemap.c",
      "libyasm/md5.c",
      "libyasm/mergesort.c",
      "libyasm/section.c",
      "libyasm/strcasecmp.c",
      "libyasm/strsep.c",
      "libyasm/symrec.c",
      "libyasm/valparam.c",
      "libyasm/value.c",
      "modules/arch/lc3b/lc3barch.c",
      "modules/arch/lc3b/lc3bbc.c",
      "modules/arch/x86/x86arch.c",
      "modules/arch/x86/x86bc.c",
      "modules/arch/x86/x86expr.c",
      "modules/arch/x86/x86id.c",
      "modules/dbgfmts/codeview/cv-dbgfmt.c",
      "modules/dbgfmts/codeview/cv-symline.c",
      "modules/dbgfmts/codeview/cv-type.c",
      "modules/dbgfmts/dwarf2/dwarf2-aranges.c",
      "modules/dbgfmts/dwarf2/dwarf2-dbgfmt.c",
      "modules/dbgfmts/dwarf2/dwarf2-info.c",
      "modules/dbgfmts/dwarf2/dwarf2-line.c",
      "modules/dbgfmts/null/null-dbgfmt.c",
      "modules/dbgfmts/stabs/stabs-dbgfmt.c",
      "modules/listfmts/nasm/nasm-listfmt.c",
      "modules/objfmts/bin/bin-objfmt.c",
      "modules/objfmts/coff/coff-objfmt.c",
      "modules/objfmts/coff/win64-except.c",
      "modules/objfmts/dbg/dbg-objfmt.c",
      "modules/objfmts/elf/elf-objfmt.c",
      "modules/objfmts/elf/elf-x86-amd64.c",
      "modules/objfmts/elf/elf-x86-x32.c",
      "modules/objfmts/elf/elf-x86-x86.c",
      "modules/objfmts/elf/elf.c",
      "modules/objfmts/macho/macho-objfmt.c",
      "modules/objfmts/rdf/rdf-objfmt.c",
      "modules/objfmts/xdf/xdf-objfmt.c",
      "modules/parsers/gas/gas-parse-intel.c",
      "modules/parsers/gas/gas-parse.c",
      "modules/parsers/gas/gas-parser.c",
      "modules/parsers/nasm/nasm-parse.c",
      "modules/parsers/nasm/nasm-parser.c",
      "modules/preprocs/cpp/cpp-preproc.c",
      "modules/preprocs/nasm/nasm-eval.c",
      "modules/preprocs/nasm/nasm-pp.c",
      "modules/preprocs/nasm/nasm-preproc.c",
      "modules/preprocs/nasm/nasmlib.c",
      "modules/preprocs/raw/raw-preproc.c",

      # Files generated by compile_gperf
      "$target_gen_dir/x86cpu.c",
      "$target_gen_dir/x86regtmod.c",

      # Files generated by compile_re2c
      "$target_gen_dir/gas-token.c",
      "$target_gen_dir/nasm-token.c",

      # File generated by compile_re2c_lc3b
      "$target_gen_dir/lc3bid.c",

      # File generated by generate_module
      "$target_gen_dir/module.c",
    ]

    configs += [
      ":yasm_config",
      ":yasm_warnings",
    ]

    # Yasm generates a bunch of .c files which its source file #include.
    # Add the |target_gen_dir| into the include path so it can find them.
    # Ideally, these generated .c files would be placed into a separate
    # directory, but the gen_x86_insn.py script does not make this easy.
    include_dirs = [ yasm_gen_include_dir ]

    cflags = [
      "-std=c89",
      "-pedantic",
    ]

    # TODO(ajwong): This should take most of the generated output as
    # inputs.
    deps = [
      ":compile_gperf",
      ":compile_gperf_for_include",
      ":compile_nasm_macros",
      ":compile_nasm_version",
      ":compile_re2c",
      ":compile_re2c_lc3b",
      ":compile_win64_gas",
      ":compile_win64_nasm",
      ":generate_license",
      ":generate_module",
      ":generate_version",
      ":yasm_utils",
    ]
  }

  compiled_action_foreach("compile_gperf") {
    tool = ":genperf"
    sources = [
      "modules/arch/x86/x86cpu.gperf",
      "modules/arch/x86/x86regtmod.gperf",
    ]

    outputs = [
      "$target_gen_dir/{{source_name_part}}.c",
    ]
    args = [
      "{{source}}",
      rebase_path(target_gen_dir, root_build_dir) + "/{{source_name_part}}.c",
    ]
    deps = [
      ":generate_x86_insn",
    ]
  }

  # This differs from |compile_gperf| in where it places it output files.
  compiled_action_foreach("compile_gperf_for_include") {
    tool = ":genperf"
    sources = [
      # Make sure the generated gperf files in $target_gen_dir are synced with
      # the outputs for the related generate_*_insn actions in the
      # generate_files target below.
      #
      # The output for these two are #included by
      #   modules/arch/x86/x86id.c
      "$yasm_gen_include_dir/x86insn_gas.gperf",
      "$yasm_gen_include_dir/x86insn_nasm.gperf",
    ]

    outputs = [
      "$yasm_gen_include_dir/{{source_name_part}}.c",
    ]
    args = [
      "{{source}}",
      rebase_path(yasm_gen_include_dir, root_build_dir) +
          "/{{source_name_part}}.c",
    ]
    deps = [
      ":generate_x86_insn",
    ]
  }

  template("compile_macro") {
    compiled_action(target_name) {
      tool = ":genmacro"

      # Output #included by frontends/yasm/yasm.c.
      inputs = invoker.sources
      outputs = invoker.outputs
      args = [
        rebase_path(outputs[0], root_build_dir),
        invoker.macro_varname,
        rebase_path(inputs[0], root_build_dir),
      ]
      if (defined(invoker.deps)) {
        deps = invoker.deps
      }
    }
  }

  compile_macro("compile_nasm_macros") {
    # Output #included by
    #   modules/preprocs/nasm/nasm-parser.c
    sources = [
      "modules/parsers/nasm/nasm-std.mac",
    ]
    outputs = [
      "$yasm_gen_include_dir/nasm-macros.c",
    ]
    macro_varname = "nasm_standard_mac"
  }

  compile_macro("compile_nasm_version") {
    # Output #included by
    #   modules/preprocs/nasm/nasm-preproc.c
    sources = [
      "$target_gen_dir/$version_file",
    ]
    outputs = [
      "$yasm_gen_include_dir/nasm-version.c",
    ]
    macro_varname = "nasm_version_mac"
    deps = [
      ":generate_version",
    ]
  }

  compile_macro("compile_win64_gas") {
    # Output #included by frontends/yasm/yasm.c.
    sources = [
      "modules/objfmts/coff/win64-gas.mac",
    ]
    outputs = [
      "$yasm_gen_include_dir/win64-gas.c",
    ]
    macro_varname = "win64_gas_stdmac"
  }

  compile_macro("compile_win64_nasm") {
    # Output #included by frontends/yasm/yasm.c.
    sources = [
      "modules/objfmts/coff/win64-nasm.mac",
    ]
    outputs = [
      "$yasm_gen_include_dir/win64-nasm.c",
    ]
    macro_varname = "win64_nasm_stdmac"
  }

  compiled_action_foreach("compile_re2c") {
    tool = ":re2c"
    sources = [
      "modules/parsers/gas/gas-token.re",
      "modules/parsers/nasm/nasm-token.re",
    ]
    outputs = [
      "$target_gen_dir/{{source_name_part}}.c",
    ]
    args = [
      "-b",
      "-o",
      rebase_path(target_gen_dir, root_build_dir) + "/{{source_name_part}}.c",
      "{{source}}",
    ]
  }

  # This call doesn't fit into the re2c template above.
  compiled_action("compile_re2c_lc3b") {
    tool = ":re2c"
    inputs = [
      "modules/arch/lc3b/lc3bid.re",
    ]
    outputs = [
      "$target_gen_dir/lc3bid.c",
    ]
    args = [
      "-s",
      "-o",
      rebase_path(outputs[0], root_build_dir),
      rebase_path(inputs[0], root_build_dir),
    ]
  }

  compiled_action("generate_license") {
    tool = ":genstring"

    # Output #included by frontends/yasm/yasm.c.
    inputs = [
      "COPYING",
    ]
    outputs = [
      "$yasm_gen_include_dir/license.c",
    ]
    args = [
      "license_msg",
      rebase_path(outputs[0], root_build_dir),
      rebase_path(inputs[0], root_build_dir),
    ]
  }

  compiled_action("generate_module") {
    tool = ":genmodule"
    inputs = [
      "libyasm/module.in",
      config_makefile,
    ]
    outputs = [
      "$target_gen_dir/module.c",
    ]
    args = [
      rebase_path(inputs[0], root_build_dir),
      rebase_path(config_makefile, root_build_dir),
      rebase_path(outputs[0], root_build_dir),
    ]
  }

  compiled_action("generate_version") {
    tool = ":genversion"
    outputs = [
      "$target_gen_dir/$version_file",
    ]
    args = [ rebase_path(outputs[0], root_build_dir) ]
  }

  action("generate_x86_insn") {
    script = "modules/arch/x86/gen_x86_insn.py"

    # Output eventually #included by frontends/yasm/x86id.c
    outputs = [
      "$yasm_gen_include_dir/x86insns.c",
      "$yasm_gen_include_dir/x86insn_gas.gperf",
      "$yasm_gen_include_dir/x86insn_nasm.gperf",
    ]
    args = [ rebase_path(yasm_gen_include_dir, root_build_dir) ]
  }
}