third_party/yasm/yasm_assemble.gni

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 # This provides the yasm_assemble() template which uses YASM to assemble
   6 # assembly files.
   7 #
   8 # Files to be assembled with YASM should have an extension of .asm.
   9 #
  10 # Parameters
  11 #
  12 #   yasm_flags (optional)
  13 #       [list of strings] Pass additional flags into YASM. These are appended
  14 #       to the command line. Note that the target machine type and system is
  15 #       already set up based on the current toolchain so you don't need to
  16 #       specify these things (see below).
  17 #
  18 #       Example: yasm_flags = [ "--force-strict" ]
  19 #
  20 #   include_dirs (optional)
  21 #       [list of dir names] List of additional include dirs. Note that the
  22 #       source root and the root generated file dir is always added, just like
  23 #       our C++ build sets up.
  24 #
  25 #       Example: include_dirs = [ "//some/other/path", target_gen_dir ]
  26 #
  27 #   defines (optional)
  28 #       [list of strings] List of defines, as with the native code defines.
  29 #
  30 #       Example: defines = [ "FOO", "BAR=1" ]
  31 #
  32 #   inputs, deps, visibility  (optional)
  33 #       These have the same meaning as in an action.
  34 #
  35 # Example
  36 #
  37 #   yasm_assemble("my_yasm_target") {
  38 #     sources = [
  39 #       "ultra_optimized_awesome.asm",
  40 #     ]
  41 #     include_dirs = [ "assembly_include" ]
  42 #   }
  43
  44 if (is_mac || is_ios) {
  45   if (current_cpu == "x86") {
  46     _yasm_flags = [
  47       "-fmacho32",
  48       "-m",
  49       "x86",
  50     ]
  51   } else if (current_cpu == "x64") {
  52     _yasm_flags = [
  53       "-fmacho64",
  54       "-m",
  55       "amd64",
  56     ]
  57   }
  58 } else if (is_posix) {
  59   if (current_cpu == "x86") {
  60     _yasm_flags = [
  61       "-felf32",
  62       "-m",
  63       "x86",
  64     ]
  65   } else if (current_cpu == "x64") {
  66     _yasm_flags = [
  67       "-DPIC",
  68       "-felf64",
  69       "-m",
  70       "amd64",
  71     ]
  72   }
  73 } else if (is_win) {
  74   if (current_cpu == "x86") {
  75     _yasm_flags = [
  76       "-DPREFIX",
  77       "-fwin32",
  78       "-m",
  79       "x86",
  80     ]
  81   } else if (current_cpu == "x64") {
  82     _yasm_flags = [
  83       "-fwin64",
  84       "-m",
  85       "amd64",
  86     ]
  87   }
  88 }
  89
  90 if (is_win) {
  91   asm_obj_extension = "obj"
  92 } else {
  93   asm_obj_extension = "o"
  94 }
  95
  96 template("yasm_assemble") {
  97   # TODO(ajwong): Support use_system_yasm.
  98   assert(defined(invoker.sources), "Need sources defined for $target_name")
  99
 100   # Only depend on YASM on x86 systems. Force compilation of .asm files for
 101   # ARM to fail.
 102   assert(current_cpu == "x86" || current_cpu == "x64")
 103
 104   action_name = "${target_name}_action"
 105   source_set_name = target_name
 106
 107   action_foreach(action_name) {
 108     # Only the source set can depend on this.
 109     visibility = [ ":$source_set_name" ]
 110
 111     script = "//third_party/yasm/run_yasm.py"
 112     sources = invoker.sources
 113
 114     if (defined(invoker.inputs)) {
 115       inputs = invoker.inputs
 116     }
 117
 118     # Executable (first in the args). The binary might be in the root build dir
 119     # (no cross-compiling) or in a toolchain-specific subdirectory of that
 120     # (when cross-compiling).
 121     yasm_label = "//third_party/yasm($host_toolchain)"
 122     args = [ "./" +  # Force current dir.
 123              rebase_path(get_label_info(yasm_label, "root_out_dir") + "/yasm",
 124                          root_build_dir) ]
 125
 126     # Deps.
 127     deps = [
 128       yasm_label,
 129     ]
 130     if (defined(invoker.deps)) {
 131       deps += invoker.deps
 132     }
 133
 134     # Flags.
 135     args += _yasm_flags
 136     if (defined(invoker.yasm_flags)) {
 137       args += invoker.yasm_flags
 138     }
 139
 140     # User defined include dirs go first.
 141     if (defined(invoker.include_dirs)) {
 142       foreach(include, invoker.include_dirs) {
 143         args += [ "-I" + rebase_path(include, root_build_dir) ]
 144       }
 145     }
 146
 147     # Default yasm include dirs. Make it match the native build (source root and
 148     # root generated code directory).
 149     # This goes to the end of include list.
 150     args += [
 151       "-I.",
 152
 153       # Using "//." will produce a relative path "../.." which looks better than
 154       # "../../" which will result from using "//" as the base (although both
 155       # work). This is because rebase_path will terminate the result in a
 156       # slash if the input ends in a slash.
 157       "-I" + rebase_path("//.", root_build_dir),
 158       "-I" + rebase_path(root_gen_dir, root_build_dir),
 159     ]
 160
 161     # Extra defines.
 162     if (defined(invoker.defines)) {
 163       foreach(def, invoker.defines) {
 164         args += [ "-D$def" ]
 165       }
 166     }
 167
 168     # Output file.
 169     #
 170     # TODO(brettw) it might be nice if there was a source expansion for the
 171     # path of the source file relative to the source root. Then we could
 172     # exactly duplicate the naming and location of object files from the
 173     # native build, which would be:
 174     # "$root_out_dir/${target_name}.{{source_dir_part}}.$asm_obj_extension"
 175     outputs = [
 176       "$target_out_dir/{{source_name_part}}.o",
 177     ]
 178     args += [
 179       "-o",
 180       rebase_path(outputs[0], root_build_dir),
 181       "{{source}}",
 182     ]
 183
 184     # The wrapper script run_yasm will write the depfile to the same name as
 185     # the output but with .d appended (like gcc will).
 186     depfile = outputs[0] + ".d"
 187   }
 188
 189   # Gather the .o files into a linkable thing. This doesn't actually link
 190   # anything (a source set just compiles files to link later), but will pass
 191   # the object files generated by the action up the dependency chain.
 192   source_set(source_set_name) {
 193     if (defined(invoker.visibility)) {
 194       visibility = invoker.visibility
 195     }
 196
 197     sources = get_target_outputs(":$action_name")
 198
 199     deps = [
 200       ":$action_name",
 201     ]
 202   }
 203 }